diff --git a/1_Basics_IV.ipynb b/1_Basics_IV.ipynb index 9db1210b..8069a07b 100644 --- a/1_Basics_IV.ipynb +++ b/1_Basics_IV.ipynb @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 2, "metadata": { "hidden": true, "tags": [ @@ -97,6 +97,14 @@ ] }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.\n", + "Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.\n" + ] + }, { "data": { "image/png": "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\n", @@ -109,7 +117,7 @@ " \n", " \n", " \n", - " 2024-03-06T11:10:55.525005\n", + " 2024-03-07T19:39:13.060542\n", " image/svg+xml\n", " \n", " \n", @@ -535,7 +543,7 @@ "L 39.06 54.54 \n", "L 75.06 54.54 \n", "z\n", - "\" clip-path=\"url(#pcd1d4bc47a)\" style=\"fill: none; stroke: #000000; stroke-linecap: round\"/>\n", + "\" clip-path=\"url(#pd41ff0ad6c)\" style=\"fill: none; stroke: #000000; stroke-linecap: round\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\" style=\"fill: none; stroke: #000000; stroke-linecap: round\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\" style=\"fill: none; stroke: #000000; stroke-linecap: round\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\" style=\"fill: none; stroke: #000000; stroke-linecap: round\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\" style=\"fill: none; stroke: #000000; stroke-linecap: round\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\" style=\"fill: none; stroke: #000000; stroke-linecap: round\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\" style=\"fill: none; stroke: #000000; stroke-linecap: round\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\" style=\"fill: none; stroke: #000000; stroke-linecap: round\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\" style=\"fill: none; stroke: #000000; stroke-linecap: round\"/>\n", " \n", " \n", " \n", + "\" clip-path=\"url(#pd41ff0ad6c)\"/>\n", " \n", " \n", " \n", @@ -1705,14 +1713,14 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", "\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -6076,7 +6084,6 @@ { "cell_type": "markdown", "metadata": { - "heading_collapsed": true, "hidden": true }, "source": [ @@ -15201,42 +15208,35 @@ }, { "cell_type": "markdown", - "metadata": { - "heading_collapsed": true - }, + "metadata": {}, "source": [ "## `for`ループ" ] }, { "cell_type": "markdown", - "metadata": { - "heading_collapsed": true, - "hidden": true - }, + "metadata": {}, "source": [ "### 説明" ] }, { "cell_type": "markdown", - "metadata": { - "hidden": true - }, + "metadata": {}, "source": [ "ループとは同じコードを複数回続けて実行できるように書かれたコードを指す。ループには2つのタイプがあるが,`for`ループは指定した回数だけ処理を繰り返す計算手続きである。次のような書き方となる。\n", "\n", "```\n", "for <イタラブルの要素を割り当てる変数> in <イタラブル>:\n", - " <毎回実行したい内容1>\n", + " <毎回実行したいコード>\n", "```\n", "\n", "* 1行目\n", - " * `<イタラブル>`(iterable)とはリストやタプルのように要素を1つずつ返すことができる反復可能なデータ型(オブジェクト)を指す。文字列や後に説明する`Numpy`の`array`も含まれる。 \n", - " * `<イタラブルの要素を割り当てる変数>`とはループを1回実行する際に`<イタラブル>`の要素の値を割り当てる変数のこと。よく`i`や`j`などが使われ,再割り当てされても問題がない変数名を使おう。\n", + " * `<イタラブル>`(iterable)とはリストやタプルのように要素を1つずつ返すことができる反復可能なデータ型(オブジェクト)を指す。文字列や後に説明する`Numpy`の`array`も含まれる。\n", + " * `<イタラブルの要素を割り当てる変数>`とはループを1回実行する毎に`<イタラブル>`の要素の値を割り当てる変数のこと。よく`i`や`j`などが使われ,再割り当てされても問題がない変数名を使おう。\n", " * `for`で始まり`:`で終わり,`<イタラブル>`の前に`in`が入る。\n", "* 2行目以降\n", - " * 慣例では4つの半角スペースのインデント後に実行したいコードを書く。\n", + " * 慣例では4つの半角スペースのインデント後に毎回実行したいコードを書く。\n", "\n", "```{note}\n", "`for`ループでは無限ループは発生しない。リストなどのイタラブルの最後の要素が使われると,自動でループが終了する仕様となっている。\n", @@ -15247,249 +15247,2343 @@ }, { "cell_type": "markdown", - "metadata": { - "heading_collapsed": true, - "hidden": true - }, - "source": [ - "### `print()`を使う例" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "hidden": true - }, - "source": [ - "次のリストにはGDPの構成要素が並んでいる。" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "hidden": true - }, - "outputs": [], - "source": [ - "gdp_components = ['消費', '投資', '政府支出', '純輸出']" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "hidden": true - }, - "source": [ - "このリストにある文字列を表示したいとしよう。" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "hidden": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "消費\n", - "投資\n", - "政府支出\n", - "純輸出\n" - ] - } - ], - "source": [ - "for i in gdp_components:\n", - " print(i)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "hidden": true - }, - "source": [ - "<コードの説明>\n", - "* 1回目のループ\n", - " * 1行目で`gdp_components`の0番目の要素`消費`を`i`に割り当てる。\n", - " * 2行目で`print()`関数を使い変数`i`の値を表示する。\n", - "* 2回目のループ\n", - " * 1行目で`gdp_components`の1番目の要素`投資`を`i`に割り当てる。\n", - " * 2行目で`print()`関数を使い変数`i`の値を表示する。\n", - "* 3回目のループ\n", - " * 1行目で`gdp_components`の2番目の要素`政府支出`を`i`に割り当てる。\n", - " * 2行目で`print()`関数を使い変数`i`の値を表示する。\n", - "* 4回目のループ\n", - " * 1行目で`gdp_components`の最後の要素`純輸出`を`i`に割り当てる。\n", - " * 2行目で`print()`関数を使い変数`i`の値を表示する。\n", - "\n", - "この例では`gdp_components`の要素の数だけループが行われる。" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "hidden": true - }, - "source": [ - "### `.append()`を使う例" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "hidden": true - }, - "source": [ - "リストにはメソッド`.append()`が実装されており,これを使うとリストに値を追加することができる。`.append()`と`for`ループを使い,空のリストに値を追加し新たなリストを作成する方法を紹介する。まず元になるリストを作成しよう。" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "hidden": true - }, - "outputs": [], - "source": [ - "var_lst = [1,2,3,4,5]" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "hidden": true - }, + "metadata": {}, "source": [ - "以下では,`var_lst`のそれぞれの要素の10倍からなるリストを新たに作成する。" + "フローチャートで表すと次のようになる。" ] }, { "cell_type": "code", - "execution_count": 24, - "metadata": { - "hidden": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[10, 20, 30, 40, 50]" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lst = [] # 1\n", - "\n", - "for i in var_lst: # 2\n", - " x = 10*i # 3\n", - " my_lst.append(x) # 4\n", - "\n", - "my_lst # 5" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "hidden": true - }, - "source": [ - "<コードの説明>\n", - "\n", - "1. 空のリストの作成(`my_lst`に10倍にした数字を格納する)\n", - "2. ここから`for`ループの始まり。`i`はリスト`[1,2,3,4,5]`の要素を割り当てる変数。\n", - " * 1回目のループでは`i`に`1`を割り当てる。\n", - " * 2回目のループでは`i`に`2`を割り当てる。\n", - " * 3回目のループでは`i`に`3`を割り当てる。\n", - " * 4回目のループでは`i`に`4`を割り当てる。\n", - " * 5回目のループでは`i`に`5`を割り当てる。\n", - "3. `10*i`を計算し`x`に割り当てる。\n", - "1. `.append()`を使い`x`の値を`my_lst`に追加する。\n", - "1. `my_lst`を表示する。" - ] - }, - { - "cell_type": "markdown", + "execution_count": 45, "metadata": { - "heading_collapsed": true, - "hidden": true, "tags": [ - "remove-cell" + "hide-input" ] }, - "source": [ - "### 消費関数" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "hidden": true - }, - "source": [ - "(sec:4-consumption)=\n", - "### 消費関数" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "hidden": true - }, - "source": [ - "`for`ループを使い,所得によって消費がどのように変化するかを考えてみよう。まず`y`を所得として消費関数を次のように仮定する。\n", - "```\n", - "消費 = 100 + 0.7 * y\n", - "```\n", - "ここで\n", - "* `100`:自発的消費(autonomous consumption)\n", - " * 可処分所得がゼロであっても発生する消費支出\n", - "* `0.7`:限界消費性向(marginal propensity to consume)\n", - " * 可処分所得が`1`単位増加した場合に,どれだけ消費が増えるかを示す。例えば,月給が`10,000`円増えたとすると,その場合,`7000`円を消費に支出することを意味する。\n", - "\n", - "所得は次のリストで与えられるとする。" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "hidden": true - }, - "outputs": [], - "source": [ - "income_lst = [1000, 1100, 1500, 2000, 2300, 3000] " - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "hidden": true - }, "outputs": [ { "data": { - "text/plain": [ - "[800.0, 870.0, 1150.0, 1500.0, 1710.0, 2200.0]" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "c_lst = [] # 1\n", - "\n", + "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2024-03-07T20:30:47.219693\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.8.0, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with schemdraw.Drawing() as sd:\n", + " flow.Start(w=2, h=1).label('START')\n", + " flow.Arrow().down(sd.unit/4)\n", + " \n", + " d = flow.Decision(w=4.2, h=1.7, S='False', E='True'\n", + " ).label('イタラブルの\\n最後の要素?').drop('E')\n", + " \n", + " flow.Arrow().right(sd.unit/2)\n", + " flow.Box(w=3.2, h=1).label('毎回実行したい\\nコードを実行').drop('S')\n", + " flow.Arrow().down(sd.unit/4)\n", + " flow.Start(w=2, h=1).label('END')\n", + " \n", + " flow.Arrow().down(sd.unit/2).at(d.S)\n", + " b = flow.Box(w=3.2, h=1).label('毎回実行したい\\nコードを実行').drop('W')\n", + " \n", + " flow.Line().left(sd.unit/2).at(b.W)\n", + " flow.Wire('|-', arrow='->').linewidth(1).to(d.W)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "この図から,`for`ループの裏では`if`文が動いていることが分かると思う。「毎回実行したいコード」を実行する度に,イタラブルの最後の要素を使うかどうかを判断している。では,例を使いコードを確認してみよう。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `print()`を使う例" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "次のリストにはGDPの構成要素が並んでいる。" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "gdp_components = ['消費', '投資', '政府支出', '純輸出']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "このリストにある文字列を表示したいとしよう。" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "消費\n", + "投資\n", + "政府支出\n", + "純輸出\n" + ] + } + ], + "source": [ + "for i in gdp_components:\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<コードの説明>\n", + "* 1回目のループ\n", + " * 1行目で`gdp_components`の0番目の要素`消費`を`i`に割り当てる。\n", + " * 2行目で`print()`関数を使い変数`i`の値を表示する。\n", + "* 2回目のループ\n", + " * 1行目で`gdp_components`の1番目の要素`投資`を`i`に割り当てる。\n", + " * 2行目で`print()`関数を使い変数`i`の値を表示する。\n", + "* 3回目のループ\n", + " * 1行目で`gdp_components`の2番目の要素`政府支出`を`i`に割り当てる。\n", + " * 2行目で`print()`関数を使い変数`i`の値を表示する。\n", + "* 4回目のループ\n", + " * 1行目で`gdp_components`の最後の要素`純輸出`を`i`に割り当てる。\n", + " * 2行目で`print()`関数を使い変数`i`の値を表示する。\n", + "\n", + "この例では`gdp_components`の要素の数だけループが行われる。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `.append()`を使う例" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "リストにはメソッド`.append()`が実装されており,これを使うとリストに値を追加することができる。`.append()`と`for`ループを使い,空のリストに値を追加し新たなリストを作成する方法を紹介する。まず元になるリストを作成しよう。" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "var_lst = [1,2,3,4,5]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "以下では,`var_lst`のそれぞれの要素の10倍からなるリストを新たに作成する。" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[10, 20, 30, 40, 50]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lst = [] # 1\n", + "\n", + "for i in var_lst: # 2\n", + " x = 10*i # 3\n", + " my_lst.append(x) # 4\n", + "\n", + "my_lst # 5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<コードの説明>\n", + "\n", + "1. 空のリストの作成(`my_lst`に10倍にした数字を格納する)\n", + "2. ここから`for`ループの始まり。`i`はリスト`[1,2,3,4,5]`の要素を割り当てる変数。\n", + " * 1回目のループでは`i`に`1`を割り当てる。\n", + " * 2回目のループでは`i`に`2`を割り当てる。\n", + " * 3回目のループでは`i`に`3`を割り当てる。\n", + " * 4回目のループでは`i`に`4`を割り当てる。\n", + " * 5回目のループでは`i`に`5`を割り当てる。\n", + "3. `10*i`を計算し`x`に割り当てる。\n", + "1. `.append()`を使い`x`の値を`my_lst`に追加する。\n", + "1. `my_lst`を表示する。" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "tags": [ + "remove-cell" + ] + }, + "source": [ + "### 消費関数" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "(sec:4-consumption)=\n", + "### 消費関数" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "`for`ループを使い,所得によって消費がどのように変化するかを考えてみよう。まず`y`を所得として消費関数を次のように仮定する。\n", + "```\n", + "消費 = 100 + 0.7 * y\n", + "```\n", + "ここで\n", + "* `100`:自発的消費(autonomous consumption)\n", + " * 可処分所得がゼロであっても発生する消費支出\n", + "* `0.7`:限界消費性向(marginal propensity to consume)\n", + " * 可処分所得が`1`単位増加した場合に,どれだけ消費が増えるかを示す。例えば,月給が`10,000`円増えたとすると,その場合,`7000`円を消費に支出することを意味する。\n", + "\n", + "所得は次のリストで与えられるとする。" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "income_lst = [1000, 1100, 1500, 2000, 2300, 3000] " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[800.0, 870.0, 1150.0, 1500.0, 1710.0, 2200.0]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c_lst = [] # 1\n", + "\n", "for y in income_lst: # 2\n", " con = 100 + 0.7 * y # 3\n", " c_lst.append(con) # 4\n", @@ -15521,8 +17615,7 @@ { "cell_type": "markdown", "metadata": { - "heading_collapsed": true, - "hidden": true + "heading_collapsed": true }, "source": [ "### `for`ループの2つの書き方(動学分析の基礎)" @@ -15859,7 +17952,6 @@ "cell_type": "markdown", "metadata": { "heading_collapsed": true, - "hidden": true, "tags": [ "remove-cell" ] @@ -15972,8 +18064,7 @@ { "cell_type": "markdown", "metadata": { - "heading_collapsed": true, - "hidden": true + "heading_collapsed": true }, "source": [ "### `for`ループのお友達1:`enumerate()`関数" @@ -16146,8 +18237,7 @@ { "cell_type": "markdown", "metadata": { - "heading_collapsed": true, - "hidden": true + "heading_collapsed": true }, "source": [ "### `for`ループのお友達2:`zip()`関数"