1_Basics_III.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 関数とメソッド"
   ]
  },
  {
   "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,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 関数と引数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "コードを書くうえで関数は非常に重要な役割を果たすのが関数である。主に２つのタイプに分けることができる。\n",
    "* 組み込み関数（最初から準備されている関数）\n",
    "* ユーザー定義の関数（ユーザー自身が作成する関数）\n",
    "\n",
    "名前から想像できるが，プログラミングの関数は数学の関数と非常に似ている。数学の$y=f(x)$という関数を考えてみよう。より具体的に$f(x)=x^2$と置いてみよう。$x$は$-\\infty$から$\\infty$の実数を取ることができ，それらに対応する$y$の値が返される関数である。`Python`でも同じ関数を簡単に作ることができる。例えば，`func(x)`という関数だとしよう。`Python`では次の用語を使う。\n",
    "* `func`：関数名\n",
    "* `x`：引数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に，実際に関数を実行し計算するためには$x$に値（例えば，2）を指定する必要がある。数学の関数$f(x)$であれば$f(2)$と置くが，`Python`の関数でも同様に`func(2)`と書き，`4`が返される。この場合，次の用語を使う。\n",
    "* **引数値**：引数に指定した値である`2`\n",
    "\n",
    "まとめると，引数とは関数を実行する前に定義することになり，引数値を指定することにより関数を実行することができる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 組み込み関数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "組み込み関数（built-in functions）とは，ユーザーが使えるように事前に準備された関数である。以下が既出の組込み関数である。\n",
    "* `type()`：データ型を調べる\n",
    "* `int()`：整数型に変換\n",
    "* `float()`：不動小数点型に変換\n",
    "* `str()`：文字列型に変換\n",
    "* `bool()`：真偽値の確認\n",
    "* `list()`：リストの作成（へ変換）\n",
    "* `tuple()`：タプルの作成（へ変換）\n",
    "\n",
    "以下では別の基本的な関数を６つ紹介する。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### `sum()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`sum()`は合計を計算する関数である。引数にリストやタプルを使う。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "gdp_component = [10, 20, 30, 40]\n",
    "\n",
    "sum(gdp_component)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### `abs()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "絶対値を返す。`abs`はabsolute value（絶対値）の略。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "abs(10.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "abs(-10.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### `print()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`print()`は表示するための関数であり，引数に表示したい値を置く。Jupyter Notebookでは`print()`を使わなくとも出力が表示される。例えば，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "しかし複数行の場合は最後の行しか表示されない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "10\n",
    "200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`print()`を使うと両方を表示することができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print(10)\n",
    "print(200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "異なるオブジェクトを表示するには`,`を使う。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print('2020年の実質GDP：約', 500+25.7, '兆円')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "文字列の中で`\\n`は改行を示す。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print('マクロ\\n経済学')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に`f-string`を紹介する。文字列の前に`f`を書き加え，文字列の中で`{}`を使うことにより，割り当てた変数の値や計算結果などを表示することが可能となる。次の例を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 2/3\n",
    "\n",
    "print(f'3分の2は{x}です。')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**四捨五入**し小数点第３位まで表示する場合は，`x`の後に`:.3f`を付け加える。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print(f'3分の2は約{x:.3f}です。')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "＜`:.3f`の解釈＞\n",
    "* `:`はこの後に続くコードは表示に関するものだと「宣言」している。\n",
    "* `.`は小数点表示に関しての設定であることを示している。\n",
    "* `3`は小数点第３位を示している。\n",
    "* `f`は`float`の`f`\n",
    "\n",
    "`3f`を`5f`にすると，小数点第５位までの四捨五入となる。試してみよう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "他の引数も指定することができる。次の２つを紹介する。\n",
    "* `sep`：\n",
    "    * 複数の値を`,`で区切って表示する際，値の間に入る区切り文字を指定する。\n",
    "    * デフォルトは半角スペース\n",
    "* `end`：\n",
    "    * 行末にをどうするかを指定する\n",
    "    * デフォルトは`\\n`（改行）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print('A','B','C')\n",
    "print('A','B','C', sep='')  # 区切り文字なし\n",
    "print('A','B','C', sep='__')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print('A','B')\n",
    "print('A','B', end='')  # 改行なし\n",
    "print('A', end='___')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### `range()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`range()`は等差数列のオブジェクトを用意する関数である。次の書き方となる。\n",
    "```\n",
    "range(start,stop,step)\n",
    "```\n",
    "* `start`：最初の整数（引数を与えない場合は`0`）\n",
    "* `stop`：最後の整数の次の値\n",
    "* `step`：隣接する整数の差（公差）（引数を与えない場合は`1`）\n",
    "\n",
    "例えば，`0`から`9`までの`10`の整数を生成するには "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`0`から`10`までの整数が表示されないが，使えるように裏で準備されている。\n",
    "\n",
    "次のコードは`0`から`999,999,999`（10億-1）までの10億個の整数を準備している。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(1_000_000_000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一瞬にして10億個の整数が準備される「驚愕の速さ！」と言いたいが、実は、「準備」されただけで、10億個の整数が生成された訳ではない。実際に使うときに、`0`、`1`、`2`、`3`、、、と**順番に**整数の生成が実行されことになる。このように、各整数を使うときに「実行」することを遅延評価（lazy evaluation）と呼ぶ。「何のために使うの？」と思うだろう。理由は高速化のためであり、実際に10億個の整数からなるリストの作成には数十秒もしくは数分掛かる。例えば、次のシナリオを考えてみよう。10億個の正の整数のルートを計算するとし、計算プロセスが始まった後に計算する整数の数は（確率的に）決まるとしよう。10億個全ての整数を使うかもしれないが、もしかすると、7万個、もしくはたった5個の整数のルート計算だけで終わるかもしれない。その場合、10億個の整数を事前に準備する時間は無駄になるかも知れないし、あまりにも非効率的な手順だということは直ぐに理解できるのではないだろうか。順番に`0`、`1`、`2`、`3`、、、と必要な場合に整数の作成を実行する方が断然効率的だ。このように遅延評価するオブジェクトをジェネレーター（generator）と呼ぶ。`range()`関数は、後述する`for`ループではよく使う関数なので覚えておこう！\n",
    "\n",
    "とする。用途が明確ではないと感じるかもしれないが，`for`ループで多用することになる。またリストとして表示するには`list()`を使う。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### `list()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "リストを作成する関数。`range(10)`で準備した`0`から`9`までの整数をリストに格納しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`list()`関数を使って様々な例を表示しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "list(range(4,15+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "list(range(4,30+1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "上の例では`start`$<$`end`となっているが，不等号を逆にして`step`に負の整数を使うと降順の値が並ぶことになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "list(range(10,0,-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "list(range(10,-10,-2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "次のコードをアンコメントして（`# `を削除して）実行すると10億個の整数からなるリストを作成することができる。しかし、終了まで数分掛かるだろう！You are warned!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list( range(1_000_000_000) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### `len()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "要素の個数などを返す関数であり，引数としてリストやタプル，今後紹介する他のデータ型にも使える。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "l = [0, 1, [2, 3, 4]]\n",
    "t = (0, 1, (2, 3, 4))\n",
    "d = {'a':0, 'b':1, 'c':2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "len(l), len(t), len(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### `dir()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`Python`では全てがオブジェクトと言われており，そのオブジェクトの「中身」を見るための関数が`dir()`（directoryの略）である。使い方は，以下でより詳しく説明する。\n",
    "\n",
    "```{note}\n",
    "ここで紹介した関数名は，`type()`関数のように英単語がそのまま使われる場合と，`abs()`関数のように英単語の省略形（absoluteの省略形）となっている場合がある。前者の場合はそのまま読めば良いが，後者の場合はどう発音すれば良いかと気になったりもする。決まった発音方法がある訳ではないので，好きに読めば良いのだが，次のパターンがあるようだ。\n",
    "* 省略された単語の発音で読む。\n",
    "    * `str()`を「ストリング関数」\n",
    "* アルファベットを一文字ずつ読む。\n",
    "    * `str()`を「\"s\",\"t\",\"r\"関数」\n",
    "    * `dir()`を「\"d\",\"i\",\"r\"関数」\n",
    "* 省略形を読むパターン。\n",
    "    * `len()`は「レン関数」\n",
    "    * `dir()`は英単語\"dirty\"の\"dir\"と同じアルファベットなので，その発音に合わせて「ダー関数」\n",
    "    * 次の章で説明する`elif`はelse ifの省略形となるので「エリフ」と読む人が多いようだ。\n",
    "    * このサイトで説明はしないが特殊メソッドと呼ばれるものがあり，その一つに`.__repr__`がある。これを「レパー」と読む人がいる。なぜこうなるかというと，repを「レップ」と読み，rは「アール」だが「ル」は殆ど発音しないので，２つを続けて読むと「レパー」となる。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### `help()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "組み込み関数`help()`を使うと関数やモジュールなど説明を表示させることができる。例えば，`print()`を例として挙げる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "引数は関数名であり`()`は付いていないことに留意しよう。`()`を付けると`print()`を評価した結果に対しての説明が表示されることになる。英語での説明だがパターンを理解すればこれだけでも有用に感じることだろう。 \n",
    "\n",
    "`help()`の代わりに`?`を使うこともできる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`?print`も同じ結果を返す。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## ユーザー定義の関数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### 基本"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`def`を使って関数を定義し，引数が設定される（省略される場合もある）。ここでは基本となる引数のみを考えるが，引数の**位置**と`=`が重要な役割を果たすことになる。例を使いながら説明しよう。最初の例は数字の2乗を計算する関数である。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def func_0(x):\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "* １行目：\n",
    "    * `def`で始まり（`def`はdefinitionの省略形）`:`で終わる。\n",
    "    * `func_0`が関数名，`x`が第１引数（ひきすう）であり、この例では唯一の引数である。\n",
    "* ２行目：\n",
    "    * `return`は評価した値を「戻す」もしくは「返す」という意味。必ず`return`の前にはインデント（通常4つの半角スペース）が必要であり，ないとエラーになる。\n",
    "    * `x**2`という戻り値（返り値）の設定をする\n",
    "\n",
    "＜`return`についての補足＞<br>\n",
    "実は`return`には２つの役割がある。一つは上述の様に，値を「戻す」もしくは「返す」という役割。そして，もう一つは関数の評価を終わらせること。今の段階では，二つ目の役割はそれほど重要ではないが，後述するループが関数の中で使われる場合，「関数を終了」させる役割が活躍することになる。例えば，[この箇所のコード](sec:5-for-loop)や[この箇所のコード](sec:5-while-loop)を理解するためには`return`の二つ目の役割を知っておくことが重要になる。\n",
    "\n",
    "関数を評価するには，引数に数字を入れて実行する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "func_0(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "引数が無い関数を定義することを可能である。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def func_100():\n",
    "    return 10**2\n",
    "\n",
    "func_100()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`print()`関数を追加することもできる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def func_kobe(x):\n",
    "    print('経済学はおもしろい(^o^)/')\n",
    "    return x**2\n",
    "\n",
    "func_kobe(10)"
   ]
  },
  {
   "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": [
    "def func_1(a, b, c):\n",
    "    return a / b + c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "func_1(10, 2, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "func_1(2, 10, 10)"
   ]
  },
  {
   "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": [
    "func_1(10, c=10, b=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`=`が付いていない引数は該当する位置に書く必要があり，`10`が最初に来ないとエラーとなる。一般的なルールとして，`=`を使う引数は全て`()`の右端にまとめる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "* 関数を実行する際に`=`無しで関数に渡される引数は，その位置が重要であるため**位置引数**と呼ばれる。\n",
    "* 関数を実行する際に`=`付きで関数に渡される引数は**キーワード引数**と呼ばれる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 関数を定義する際に`=`を使う"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "関数を定義する際に`=`を使って引数のデフォルトの値を設定することができる。即ち，引数を入力すると入力された数値を使うが，引数を入力しない場合は引数に予め設定した値（デフォルトの値）が使われて評価される。次の例では`c`のデフォルトの値が`10`に設定されている。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def func_2(a, b, c=10):\n",
    "    return sum([a,b])*c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`c`の値を設定しない場合とする場合を比較してみる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "func_2(2, 3), func_2(2, 3, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "````{note}\n",
    "関数を定義する際の引数を「仮引数（parameter）」と呼ばれ，関数を実行する際の引数は「実引数（argument）」と呼ばれる。例として`func_2`関数を考えると，`a`，`b`，`c`は仮引数である。関数を実行する次のコードでは，`2`，`3`，`100`が実引数となる。\n",
    "```\n",
    "func_2(2, 3, 100)\n",
    "```\n",
    "しかし一般的には両方とも単に「引数」と呼ぶことが多いだろう。\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "tags": [
     "remove-cell"
    ]
   },
   "source": [
    "### 戻り値が複数の場合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "(sec:3-unpacking)=\n",
    "### 戻り値が複数の場合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def func_3(x):\n",
    "    return x, x**2, x**3\n",
    "\n",
    "func_3(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この場合、戻り値はタプルとして返される（タプルは`,`で定義されることを思い出そう）。次のコードは，変数`d`に戻り値を割り当てている。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "d = func_3(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`d`を実行すると次の表示となる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "従って，次のようにそれぞれの要素にアクセスすることができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "d0 = d[0]\n",
    "d1 = d[1]\n",
    "d2 = d[2]\n",
    "\n",
    "print(d0)\n",
    "print(d1)\n",
    "print(d2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "一方，タプルのアンパッキングという方法を使うと`d0`，`d1`，`d2`への割り当てをより簡単におこなうことができる。アンパッキングを説明するために，次のコードを考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "e0, e1, e2 = ('神戸', '大学', '経済')\n",
    "\n",
    "print(e0)\n",
    "print(e1)\n",
    "print(e2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "このコードは次の割り当てを同時におこなっている。\n",
    "* `神戸`　→　`e0`\n",
    "* `大学`　→　`e1`\n",
    "* `経済`　→　`e2`\n",
    "\n",
    "アンパッキングとは，「荷物をパッキングする」の反対の意味であり，上のコードは右辺の`()`で囲まれた要素を取り出して（アンパッキングして）左辺の変数に割り当てている。また，タプルはコンマ`,`で定義されるのを思い出そう。従って，右辺の`()`を省いて次のコードでも同じ結果となる。\n",
    "```\n",
    "e0, e1, e2 = '神戸', '大学', '経済'\n",
    "```\n",
    "これが[](sec:1-multiple-assignment)で説明した`=`の「複数の変数の同時割り当て」である。\n",
    "\n",
    "これを利用して，関数`func_3`の実行時に戻り値を`d0`,`d1`,`d2`に同時に割り当てることができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "d0, d1, d2 = func_3(3)\n",
    "print(d0)\n",
    "print(d1)\n",
    "print(d2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "````{tip}\n",
    "上のコードの左辺もタプルなため，次のように書くこともできる。\n",
    "```\n",
    "(d0, d1, d2) = func_3(3)\n",
    "```\n",
    "しかしタプルは`,`で定義されるので、`()`を省いても問題ない。\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### ドキュメンテーション文字列"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "文字列はシングルクォーテーション`'`もしくはダブルクォーテーション`\"`を使い作成するが，それと別にドキュメンテーション文字列（`docstring`）というものがある。こちらも`'`もしくは`\"`を使い，複数行にまたがって文字列を作成することができる。次の例は，**the Zen of Python**（`Python`コードを書く上での19の原則）と呼ばれる文章の一部である。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "s = \"\"\"Beautiful is better than ugly.\n",
    "Explicit is better than implicit.\n",
    "Simple is better than complex.\n",
    "Complex is better than complicated.\n",
    "Flat is better than nested.\n",
    "Sparse is better than dense.\n",
    "Readability counts.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この例が示す様に，`print`関数を使うと改行も含めてそのまま表示される。\n",
    "\n",
    "これを使ってユーザー定義の関数の説明を付け加えることにより，他人や将来の自分が関数を読む場合に可読性を高めることができる。次のような書き方となる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def func_0(x):\n",
    "    \"\"\"この関数はxの２乗の値を返す。\n",
    "    引数：\n",
    "        x：整数型もしくは不動小数点型\n",
    "    戻り値：\n",
    "        xの２乗\"\"\"\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "また`help()`関数を使うと付け加えて説明が表示されることになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "help(func_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### `lambda`関数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`def`を使い複雑な関数を定義することができるが，単純な関数の場合，より簡単な方法がある。それが`lambda`関数である。例として，$x^2$を計算する関数を考えよう。\n",
    "```\n",
    "def function_name(x):\n",
    "    return x**2\n",
    "```\n",
    "この関数を`lambda`関数で書き直すと次の様になる。\n",
    "```\n",
    "function_name = lambda x: x**2\n",
    "```\n",
    "右辺にある`lambda`は`lambda`関数を定義する部分であり，`def`のように必ず必要である。実際に実行してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "func_3 = lambda x: x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "func_3(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 経済学を考える"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### 将来価値"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "* `t`：時間（年; 0,1,2,...）\n",
    "* `i`：名目利子率（例えば，0.02）\n",
    "* `r`：実質利子率（例えば，0.05）\n",
    "* `pi`：インフレ率（例えば，0.03）\n",
    "\n",
    "次の式が成立する。\n",
    "\n",
    "$$\n",
    "1+r=\\dfrac{1+i}{1+pi}\n",
    "$$\n",
    "\n",
    "`x`万円を年率`i`%の利息を得る金融商品に投資し，`t`年後に現金化するとしよう。その間のインフレ率は`pi`%とした場合の`x`万円の実質将来価値を計算する関数を考える。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def future_value(x, i, pi, t):\n",
    "    r = (1+i)/(1+pi)-1\n",
    "    return x*(1+r)**t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "future_value(100, 0.05, 0.03, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### 現在価値"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`t`年後に`x`万円をもらえるとしよう。`x`万円の現在価値を計算する関数を考える。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def current_value(x, i, inf, t):\n",
    "    r = (1+i)/(1+inf)-1\n",
    "    return x/(1+r)**t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "current_value(100, 0.05, 0.03, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### 複利計算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "* `y0`：元金\n",
    "* `t`：投資期間\n",
    "* `r`：実質利子率（年率）\n",
    "* `m`：複利の周期（年間の利息発生回数）\n",
    "    * 例えば，毎月利息が発生する場合は`m=12`\n",
    "* `yt`：`t`年後の元利合計\n",
    "\n",
    "$$\n",
    "yt=y0\\left( 1+\\dfrac{r}{m}  \\right)^{mt}\n",
    "$$\n",
    "\n",
    "`t`年後の元利合計を計算する関数を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def calculate_yt(y0=100, r=0.05, m=1, t=10):\n",
    "    return y0*( 1+r/m )**(m*t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "calculate_yt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "calculate_yt(m=12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "(object)="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## オブジェクトと属性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 属性について"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`Python`を習うと「オブジェクト」という単語が必ず出てくる。今の内にイメージをつかむために自転車をオブジェクトの例として考えてみよう。通常の自転車には車輪が２つあり、サドルが１つあり、左右にペダルが２つある。これらの数字が自転車に関する**データ**である。またペダルを踏むことにより前に動き、ハンドルを右にきると右方向に進むことになる。即ち、あることを実行すると、ある結果が返されるのである。これは数学の**関数**と同じように理解できる。$y=x^2$の場合、$x$が`2`であれば$y$の値として`4`が返される。このように自転車はデータと関数が備わっているオブジェクトとして考えることができる。また、車輪の数やペダルを踏むことは自転車特有のデータと関数であり、他のオブジェクト（例えば、冷蔵庫）にはない。即ち、世の中の「オブジェクト」にはそれぞれ異なるデータと関数が存在していると考えることができる。\n",
    "\n",
    "`Python`の世界でもすべてをこれと同じように考える。コードセルに書いた`10`を実行すると，その`10`がオブジェクトであり，データと関数が備わることになる。それらを**属性**（attributes）と呼ぶ。`10`は単なる数字に見えるが、実は様々な属性から構成されるオブジェクトなのである。上の例の自転車のように、属性は次の２つに分類される。`10`を例にとると、\n",
    "1. `10`が持つ様々な**データ属性**（data attribute）（例えば、`10`という値や整数という情報）\n",
    "1. `10`特有の関数である**メソッド**（method）（例えば、加算、除算のように`10`というデータに働きかける関数）\n",
    "\n",
    "を指す（呼称については[Pythonの公式サイト](https://docs.python.org/ja/3/tutorial/classes.html#instance-objects)を参照）。自転車と冷蔵庫は異なるデータと関数を持つように、整数`10`と文字列`マクロ経済学`は異なるデータと関数を備えるオブジェクトなのである。この考え方は`Python`のすべてに当てはまる。即ち、Everything is an object in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```{note}\n",
    "データ属性もメソッドもオブジェクトの属性には変わりないが，これ以降このサイトではこの２つを次のように呼ぶことにする。\n",
    "* データ属性 → 「属性」\n",
    "* メソッド → 「メソッド」\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "属性の例を考えるために浮動小数点型`10.0`を`y`に割り当てよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "y = 10.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`y`の属性は`dir()`という組み込み関数を使うことにより表示できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [],
   "source": [
    "dir(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この中の最後にある`real`は数字の実部を表し，実数である`10.0`の実部は`10.0`である。一方，`imag`は複素数の虚部を表すが，`10.0`は複素数ではないので`0.0`になっている。（上で紹介しなかったが，データ型に複素数型もある。）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "y.real, y.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "上の属性のリストにある`_`はアンダースコア（underscore）と呼ぶが，２つ連続した場合`__`となりダブル・アンダースコア（double underscore）と呼ぶ。長いのでダンダー（dunder）と省略する場合が多々ある。また，`.__init__`のような属性は特殊属性と呼ばれるが，ダンダー属性と呼ぶこともある。ダンダー属性は`Python`が裏で使うものでありユーザーが直接使う属性ではない。\n",
    "\n",
    "次にメソッドを考えるために次のリストを例に挙げる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "my_list = [1,2,3]\n",
    "\n",
    "dir(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この中に`append`があるが，`my_list`に要素を追加するメソッドであることは説明した。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "my_list.append(100)\n",
    "\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```{note}\n",
    "* （データ）属性と異なりメソッドは`()`が必要となる。これは関数の`()`に対応している。`()`を「する」もしくは「実行する」と読めば分かりやすいだろう。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 関数とメソッドの違い"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "本章の最初で関数について説明し，ここではメソッドについて解説した。その説明を読んでも，関数とメソッドの違いが不明瞭だと感じる読者もいるだろう。ここでは，その違いを再度考えてみる。関数とメソッドの役割は基本的には同じだが，で異なる点を図{numref}`fig:3-method`にまとめた。\n",
    "\n",
    "まず，コードを実行するとメモリー上にデータが保存され，それをオブジェクトと呼ぶことはもう分かっているだろう。例えば，`x=[1,2,3]`を実行すると，メモリー上に`[1,2,3]`が保存され，その参照記号が`x`となる。この場合，`[1,2,3]`がオブジェクトである。同様に，`y=10`を実行すると，`10`というオブジェクトが保存される（`y`は参照記号）。\n",
    "\n",
    "関数の特徴は，様々なオブジェクトに適用できることだ。`print()`関数は，異なるオブジェクトである`x`にも`y`にも使うことができる。そういう意味では，関数を適用できる用途は広い。図{numref}`fig:3-method`にあるように，イメージ的には，様々な用途に使える懐中電灯のようなものだろうか。\n",
    "\n",
    "一方，メソッドはオブジェクトに元々備わっている関数である。例えば，`.append()`はリストである`[1,2,3]`に備わっている関数であり，整数型である`10`には備わっていない。`.append()`は，それが実装されている`[1,2,3]`に働きかける関数であり，実行後にその結果を返すことになる。そういう意味では，メソッドの用途は限られている。図{numref}`fig:3-method`にあるように，車のヘッドライトをイメージしてはどうだろうか。ヘッドライトは，夜走行する際に，安全のために装備された車の前方を照らすことが主な目的であり，他の用途に使うことは不可能ではないだろうが，難しいのではないだろうか。もう一点付け加えると，`x.append(100)`の場合，`100`を`x`に追加するが，その裏では`()`の中に`x`が引数として設定されことになる。\n",
    "\n",
    "\n",
    "```{figure} /images/method.png\n",
    "---\n",
    "scale: 35%\n",
    "name: fig:3-method\n",
    "---\n",
    "関数とメソッドの違い\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "tags": [
     "remove-cell"
    ]
   },
   "source": [
    "## スコープ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "(sec:3-scope)=\n",
    "## スコープ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "値を表示する関数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100 / 3\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### 説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "スコープとは、変数が所属し直接アクセスできるコードの中の「領域」を示す。類似する概念に名前空間（Namespace）もあるが、スコープの情報を記す「表」のことであり、スコープ（Scope）と同義と理解すれば良い。\n",
    "\n",
    "ここでは基本的に以下のように理解すれば良いであろう。\n",
    "\n",
    "* Jupyter Notebookを開始した時点からglobalスコープが始まる。\n",
    "* 関数を定義すると、その関数の範囲内でlocalスコープが生成される。\n",
    "* globalスコープで定義された変数は、localスコープからアクセスできるが、globalスコープからlocalスコープの変数にはアクセスできない。\n",
    "* 関数を実行すると次の順番で変数を探す。\n",
    "    1. 関数のローカス・スコープ\n",
    "    2. グローバル・スコープ\n",
    "\n",
    "次の例を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "s = \"Kobe Univ\"   # globalスコープ\n",
    "\n",
    "def scope_0():\n",
    "    s = \"神戸大学\"  # localスコープ\n",
    "    return s\n",
    "\n",
    "scope_0()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この関数を実行すると、Pythonはまず関数`scope_0`のローカル・スコープ内で変数`s`を探すことになる。ローカル・スコープに`s`があるので、それを返している。次の関数を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def scope_1():\n",
    "    return s\n",
    "\n",
    "scope_1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この例では、まず`Python`はローカル・スコープに`s`があるかを確かめる。ローカル・スコープにないため、次にグローバル・スコープに`s`がないかを確かめている。グローバル・スコープに`s`があったので、それを返している（ないとエラーが出る）。\n",
    "\n",
    "次の例では、グローバル・スコープからローカル・スコープの変数へのアクセスを考える。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def scope_2():\n",
    "    s_local = 'Pythonは楽しい(^o^)/'\n",
    "    return s_local\n",
    "\n",
    "scope_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`s_local`は関数`scope_2`のローカル・スコープで定義されている。グローバル・スコープからアクセスしようとするとエラーが発生する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "s_local"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "以上の説明を図{numref}`fig:3-scope`にまとめる次のようになる。\n",
    "\n",
    "```{figure} /images/scope.png\n",
    "---\n",
    "scale: 35%\n",
    "name: fig:3-scope\n",
    "---\n",
    "グローバル・スコープとローカル・スコープの関係\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 教訓１"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "> * 関数内で使う変数は、可能な限り関数内で定義する方が意図しない結果につながるリスクを軽減できる。\n",
    "> * グローバル・スコープで定義した変数を関数に使いたい場合は、引数として同じ変数を使う。\n",
    "\n",
    "次の例を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここで`a`に`4`を割り当てたが，この値を忘れて（知らずに）`10`だったと勘違いして次の関数を定義したとしよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def scope_3(x):\n",
    "    return x + a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`scope_3(10)`は`20`を返すと思って実行すると意図しない結果になる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "scope_3(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "このような場合は`a`を引数に使うことにより問題を回避できる。`a`は`10`として関数を実行すると意図した結果となる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def scope_4(x,a):\n",
    "    return x + a\n",
    "\n",
    "scope_4(10,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この場合、関数`scope_4(x,a)`の`a`はローカル・スコープで定義され、グルーバル・スコープの`a`とは異なる。実際、グルーバル・スコープの`a`の値を確認してみると以前と同じ値`4`である。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ちなみに、グローバル・スコープの変数名や関数名は`%who`もしくは`%whos`のコマンドで確認できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "%who"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "このリストにある`s`はグローバル・スコープの`s`である。またローカル・スコープにある`s_local`はこのリストには含まれていない。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### 教訓２"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "> `for`ループの１行目に使う変数は再割り当てされても構わない変数を使おう。\n",
    "\n",
    "`for`ループは次の章で出てくるので，この箇所はスキップして良いだろう。だが，`for`ループを学んだ後，もう一度こちらに戻ってきて読んでみよう。\n",
    "\n",
    "例を使って説明しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この`for`ループの`i`は`range(5)`の連番`0`、`1`、`2`、`3`、`4`を指す変数として使われるが、グローバル・スコープの変数として存在し、ループの最後の値が割り当てられている。確認してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`for`ループで使う変数は、ループ用の変数を使うようにしよう。"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}