From 72110d88200b2ebfde6cf74294838ef13dbf5c4c Mon Sep 17 00:00:00 2001 From: Tetsu Haruyama Date: Wed, 6 Mar 2024 22:32:17 +0900 Subject: [PATCH] flow for if --- 1_Basics_IV.ipynb | 6791 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 6633 insertions(+), 158 deletions(-) diff --git a/1_Basics_IV.ipynb b/1_Basics_IV.ipynb index 2558a97f..8b6bf946 100644 --- a/1_Basics_IV.ipynb +++ b/1_Basics_IV.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -50,9 +50,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15\n" + ] + } + ], "source": [ "x = 10 #1\n", "y = 5 #2\n", @@ -75,13 +83,1635 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": { "tags": [ - "remove-input" + "hide-input" ] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2024-03-06T11:10:55.525005\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" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from schemdraw import flow\n", "import schemdraw\n", @@ -104,7 +1734,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "一番最初と最後の横長丸枠は,プログラムの始まり(`START`)と終わり(`END`)を表す。長方形枠はコードの処理,そして,矢印はプログラムの実行の順番(フロー)を意味する。単純な例となるので,上から下に一直線の実行フローとなっている。より複雑なコードの場合,矢印が横向きや上向きになったりもし,枠も様々な形を使い実行フローを表現することになる。以下では,枠は次の3種類だけを使い制御フローをシンプルな形で表すことにする。\n", + "一番最初と最後の横長丸枠は,プログラムの始まり(`START`)と終わり(`END`)を表す。長方形枠はコードの処理,そして,矢印はプログラムの実行の順番(フロー)を意味する。単純な例なので,上から下に一直線の実行フローとなっている。より複雑なコードの場合,矢印が横向きや上向きになったりもし,枠も様々な形を使い実行フローを表現することになる。以下では,枠は次の3種類だけを使い制御フローをシンプルな形で表すことにする。\n", "* 横長丸枠(端子):プログラムの始まりと終わり\n", "* 長方形枠(処理):コードの処理\n", "* 菱形(判断):条件分岐\n", @@ -121,20 +1751,22 @@ }, { "cell_type": "markdown", - "metadata": { - "heading_collapsed": true - }, + "metadata": {}, "source": [ "### 説明と簡単な例" ] }, { "cell_type": "markdown", - "metadata": { - "hidden": true - }, + "metadata": {}, + "source": [ + "`if`文を使うと,指定した条件によって処理を複数パターンに分けることができる。条件をブール型(真偽)(`True`又は`False`)で判断しコードを実行することになる。次の構文となる。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, "source": [ - "`if`文を使うと,指定した条件によって処理を複数パターンに分けることができる。条件をブール型(真偽)(`True`又は`False`)で判断しコードを実行することになる。次の構文となる。\n", "```\n", "if <条件1>:\n", " <条件1が`True`の場合に実行するコード>\n", @@ -152,73 +1784,4480 @@ "* `<条件...がTrueの場合に実行するコード>`の行はインデント(4つの半角スペース)されている。\n", "* `elif`(else ifの略)の行も`:`で終わる。\n", "* `else`の行も`:`で終わる。\n", + "* 条件が1つの場合は,`elif`がある行を書く必要はない。\n", + "* `else`の行は省略可能。その場合は,次のコードと等しい。\n", + " \n", + " ```\n", + " else:\n", + " pass\n", + " ```\n", + " 即ち,「全ての条件が`False`の場合は何も実行しない」という意味になる。\n", "\n", - "例を考えよう。" + "条件が1つの例を考えよう。" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "hidden": true - }, - "outputs": [], - "source": [ - "x = 10\n", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "条件はTrueです。\n" + ] + } + ], + "source": [ + "x = 10 #1\n", "\n", - "if x == 10: # 1\n", - " print('条件はTrueです。') # 2\n", + "if x == 10: #2\n", + " print('条件はTrueです。') #3\n", "\n", - "else: # 3\n", - " print('条件はFalseです。') # 4" + "else: #4\n", + " print('条件はFalseです。') #5" ] }, { "cell_type": "markdown", + "metadata": {}, + "source": [ + "<コードのの説明>\n", + "* `#1`:`10`を`x`に割り当てる。\n", + "* `#2`:`x`が`10`と等しいかを判断する。\n", + " * `x==10`が`True`の場合は,`#3`が実行され,`条件はTrueです。`が表示さる。コード・セルの実行はこれで終了する。\n", + " * `x==10`が`False`の場合は,`#3`は実行されず,`#4`に進む。\n", + "* `#4`から`x==10`が`False`のケースがはじまる。\n", + "* `#5`が実行され,`条件はFalseです。`が表示さる。コード・セルの実行はこれで終了する。\n", + "\n", + "もちろん,上のコード・セルを実行すると,`#3`で処理は終了することになる。この`if`文をフローチャートで表してみよう。" + ] + }, + { + "cell_type": "code", + "execution_count": 78, "metadata": { - "hidden": true + "tags": [ + "hide-input" + ] }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2024-03-06T20:08:06.929430\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", + " \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", + " b = flow.Box(w=2, h=1).label('x = 10')\n", + " flow.Arrow().down(sd.unit/4)\n", + " d = flow.Decision(w=3, h=1.3, S='True', E='False').label('x = 10 ?').drop('S')\n", + " flow.Arrow().down(sd.unit/3)\n", + " b = flow.Box(w=3.7, h=1.3).label('「条件はTrueです。」\\nの表示')\n", + " flow.Arrow().down(sd.unit/4)\n", + " flow.Start(w=2, h=1).label('END')\n", + " \n", + " flow.Arrow().right().at(d.E).length(2)\n", + " b = flow.Box(w=3.7, h=1.3).label('「条件はFalseです。」\\nの表示').drop('S')\n", + " flow.Arrow().down(sd.unit/4)\n", + " flow.Start(w=2, h=1).label('END')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, "source": [ - "<`if`文の説明>\n", - "1. `x`が`10`と等しいかを評価する。\n", - "1. `x==10`が`True`の場合に,`条件はTrueです。`が表示される。\n", - "1. `x==10`が`False`のケースがはじまる。\n", - "1. `x==10`が満たされない場合は,`条件はFalseです。`が表示される。\n", - "\n", - "このコードセルの最初で`10`を`x`に割り当てる。従って,`x==10`は`True`を返し,`条件はTrueです。`が表示されることになる。\n", + "菱形枠中の`?`は「判断」を意味するが,上のコードの`#2`に対応している。`x=10`は`True`なので,菱形枠から下に移動して`条件はTrueです。`が表示されることになる。\n", "\n", "次の例は上の例と似ているが少しだけ異なる。" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "hidden": true - }, + "execution_count": 81, + "metadata": {}, "outputs": [], "source": [ - "x = 20\n", + "x = 20 #1\n", "\n", - "if x == 10: # 1\n", - " print('条件はTrueです。') # 2\n", + "if x == 10: #2\n", + " print('条件はTrueです。') #3\n", "\n", - "else: # 3\n", - " pass # 4" + "else: #4\n", + " pass #5" ] }, { "cell_type": "markdown", - "metadata": { - "hidden": true - }, + "metadata": {}, "source": [ - "<`if`文の説明>\n", - "* 上の`if`文と異なるのは`#4`だけである。`pass`は「何もしない」という意味\n", + "<コードの文の説明>\n", + "* 上の`if`文と異なるのは`#5`だけである。`pass`は「何もしない」という意味。\n", "\n", - "`20`が`x`に割り当てられているので,`x==10`は`False`を返す。従って,`#2`は飛ばして`else`のブロックに移ることになる。その場合の実行コードは`pass`なので何も表示されないことになる。\n", + "`20`が`x`に割り当てられているので,`x==10`は`False`を返す。従って,`#3`は飛ばして`else`のブロックに移ることになる。その場合の実行コードは`pass`なので何も表示されないことになる。\n", "\n", - "このコードで`else`以下を省略してもエラーにはならない(結果も変わらない)。即ち,`else`以下がない場合は,`#3`と`#4`が省略されていると考えることができる。" + "このコードで`else`以下を省略してもエラーにはならない(結果も変わらない)。即ち,`else`以下がない場合は,`#3`と`#4`が省略されていると考えることができる。\n", + "\n", + "フローチャートで表すと次のようになる。" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2024-03-06T22:29:16.820832\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" + ], + "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", + " b = flow.Box(w=2, h=1).label('x = 10')\n", + " flow.Arrow().down(sd.unit/4)\n", + " d = flow.Decision(w=3, h=1.3, S='True', E='False').label('x = 10 ?').drop('S')\n", + " flow.Arrow().down(sd.unit/3)\n", + " flow.Box(w=3.7, h=1.3).label('「条件はTrueです。」\\nの表示')\n", + " flow.Arrow().down(sd.unit/4)\n", + " flow.Start(w=2, h=1).label('END')\n", + " \n", + " flow.Arrow().right().at(d.E).length(2)\n", + " flow.Start(w=2, h=1).anchor('W').label('END')" ] }, { @@ -245,11 +6284,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GDPは増加しています。\n" + ] + } + ], "source": [ "change_in_gdp = 200 #1\n", "\n", @@ -291,11 +6338,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GDPは増加しています。\n" + ] + } + ], "source": [ "change_in_gdp = 200\n", "\n", @@ -347,7 +6402,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "hidden": true }, @@ -380,33 +6435,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GDPは増加しています。\n" + ] + } + ], "source": [ "gdp_change(200)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GDPは減少しています。\n" + ] + } + ], "source": [ "gdp_change(-200)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GDPは変化していません。\n" + ] + } + ], "source": [ "gdp_change(0)" ] @@ -431,7 +6510,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "hidden": true }, @@ -461,33 +6540,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "真偽値はTrueです。\n" + ] + } + ], "source": [ "truth_value('経済学')" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "真偽値はTrueです。\n" + ] + } + ], "source": [ "truth_value('0')" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "真偽値はFalseです。\n" + ] + } + ], "source": [ "truth_value(0)" ] @@ -503,7 +6606,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": { "hidden": true }, @@ -529,11 +6632,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "一文なしだよ😅\n" + ] + } + ], "source": [ "my_wallet(0)" ] @@ -573,11 +6684,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "x = -10 # 0\n", "\n", @@ -605,7 +6727,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": { "hidden": true }, @@ -637,7 +6759,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { "hidden": true }, @@ -663,11 +6785,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(10, 10, 0)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "f(10), f(-10), f(0)" ] @@ -721,7 +6854,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": { "hidden": true }, @@ -744,11 +6877,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "3.79746835443038" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "ces_production(10, 3, rho=-1)" ] @@ -820,7 +6964,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": { "hidden": true }, @@ -840,11 +6984,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "消費\n", + "投資\n", + "政府支出\n", + "純輸出\n" + ] + } + ], "source": [ "for i in gdp_components:\n", " print(i)" @@ -893,7 +7048,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": { "hidden": true }, @@ -913,11 +7068,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[10, 20, 30, 40, 50]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "my_lst = [] # 1\n", "\n", @@ -992,7 +7158,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": { "hidden": true }, @@ -1003,11 +7169,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": { "hidden": true }, - "outputs": [], + "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", @@ -1076,14 +7253,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": { "hidden": true, "tags": [ "hide-input" ] }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 10, 20, 30, 40, 50]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "[10*i for i in range(5+1)]" ] @@ -1099,11 +7287,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 10, 20, 30, 40, 50]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "k_lst = [0] #1\n", "\n", @@ -1152,11 +7351,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 10, 20, 30, 40, 50]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "k = 0 #1\n", "\n", @@ -1207,11 +7417,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "50" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "k" ] @@ -1246,11 +7467,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 10, 20, 30, 40, 50]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "def capital_accumulation(k0, period):\n", "\n", @@ -1278,11 +7510,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 10, 20, 30, 40, 50]" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "def capital_accumulation_shorter(k, period):\n", "\n", @@ -1344,7 +7587,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": { "hidden": true }, @@ -1394,11 +7637,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[100, 102.0, 104.04, 106.1208, 108.243216, 110.40808032000001]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "values = calculate_futre_value(100, 0.02, 5)\n", "values" @@ -1451,11 +7705,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[(0, 'A'), (1, 'B')]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "z = list( enumerate(['A','B']) )\n", "z" @@ -1472,11 +7737,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(0, 'A')" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "z[0]" ] @@ -1492,11 +7768,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "A\n" + ] + } + ], "source": [ "i, v = z[0]\n", "\n", @@ -1515,11 +7800,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0期:100.0万円\n", + "1期:102.0万円\n", + "2期:104.0万円\n", + "3期:106.1万円\n", + "4期:108.2万円\n", + "5期:110.4万円\n" + ] + } + ], "source": [ "for i, v in enumerate(values): #1\n", " print(f'{i}期:{v:.1f}万円') #2" @@ -1566,7 +7864,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": { "hidden": true }, @@ -1588,11 +7886,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "hidden": true - }, - "outputs": [], + "execution_count": 40, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[(1000, 0.7),\n", + " (1100, 0.71),\n", + " (1500, 0.72),\n", + " (2000, 0.73),\n", + " (2300, 0.74),\n", + " (3000, 0.75)]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "z = list( zip(income_lst, mpc_lst) )\n", "z" @@ -1619,7 +7933,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": { "hidden": true }, @@ -1639,11 +7953,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000\n", + "0.7\n" + ] + } + ], "source": [ "y, mpc = z[0]\n", "\n", @@ -1662,11 +7985,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[800.0, 881.0, 1180.0, 1560.0, 1802.0, 2350.0]" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "c_lst = [] # 1\n", "\n", @@ -1711,7 +8045,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": { "hidden": true }, @@ -1759,11 +8093,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 4, 9, 16]" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "lst = [i**2 for i in range(5)]\n", "lst" @@ -1797,11 +8142,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['0', '1', '4', '9', '16']" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "[str(i) for i in lst]" ] @@ -1826,11 +8182,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 4, 9, 16, 25, 0, 0, 0, 0, 0]" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "[x**2 if x<=5 else 0 for x in range(1,10+1)]" ] @@ -1922,11 +8289,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n" + ] + } + ], "source": [ "count = 0 #1\n", "\n", @@ -1976,11 +8353,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "ループは無事終わったよ🥳\n" + ] + } + ], "source": [ "count = 0\n", "\n", @@ -2042,11 +8430,29 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "hidden": true - }, - "outputs": [], + "execution_count": 50, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "0.5\n", + "0.25\n", + "0.125\n", + "0.0625\n", + "0.03125\n", + "0.015625\n", + "0.0078125\n", + "0.00390625\n", + "0.001953125\n", + "残りの距離は0.9765625mmです。\n" + ] + } + ], "source": [ "distance = 1 #1\n", "\n", @@ -2102,11 +8508,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "残りの距離は5.714936956411375e-101です。\n", + "333回ループ計算しました🚀\n" + ] + } + ], "source": [ "distance = 1\n", "counter = 0\n", @@ -2167,7 +8582,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "metadata": { "hidden": true }, @@ -2205,11 +8620,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "hidden": true - }, - "outputs": [], + "execution_count": 53, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50.02\n", + "25.04998400639744\n", + "12.604832373535453\n", + "6.4610854923746075\n", + "3.5400882555851294\n", + "2.335001794270127\n", + "2.0240312882070577\n", + "2.0001426615330145\n", + "2.000000005087715\n" + ] + } + ], "source": [ "sqrt_approx(4,100)" ] @@ -2247,11 +8678,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 54, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n" + ] + } + ], "source": [ "count = 0\n", "\n", @@ -2278,11 +8721,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "4\n", + "5\n" + ] + } + ], "source": [ "count = 0\n", "\n", @@ -2345,11 +8799,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 56, "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n" + ] + } + ], "source": [ "count = 0 #1\n", "\n", @@ -2400,11 +8864,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "hidden": true - }, - "outputs": [], + "execution_count": 57, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "4\n", + "5\n" + ] + } + ], "source": [ "count = 0\n", "\n",