From e17b3d4d61d89994a8a20aebe4be50c7c34de651 Mon Sep 17 00:00:00 2001
From: Tetsu Haruyama <tetsu.yes@gmail.com>
Date: Sat, 15 Jun 2024 12:04:02 +0900
Subject: [PATCH] Python 3.12 & rewritten

---
 .github/workflows/main.yml |    4 +-
 1_Python_Basics.ipynb      | 2513 +++++++++++++++++++++---------------
 20_LogitProbit.ipynb       |   10 +-
 3 files changed, 1468 insertions(+), 1059 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index ff8c6b31..2ccc1889 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -14,10 +14,10 @@ jobs:
     - uses: actions/checkout@v3
 
     # Install dependencies
-    - name: Set up Python 3.10
+    - name: Set up Python 3.12
       uses: actions/setup-python@v4
       with:
-        python-version: '3.10'
+        python-version: '3.12'
 
     - name: Install dependencies
       run: |
diff --git a/1_Python_Basics.ipynb b/1_Python_Basics.ipynb
index e5608fd0..5ef11f67 100644
--- a/1_Python_Basics.ipynb
+++ b/1_Python_Basics.ipynb
@@ -30,30 +30,22 @@
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "## `=`の意味と「オブジェクト」"
+    "## 最初の注意点"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
-   },
-   "source": [
-    "変数$x$に値`10`を「代入」するには等号`=`を使う。"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "hidden": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "x = 10"
+    "### 半角と全角 "
    ]
   },
   {
@@ -62,18 +54,18 @@
     "hidden": true
    },
    "source": [
-    "また$x$の値を表示すには、次のように$x$を書いたセルを評価するだけである。"
+    "> **半角**を基本としてコード（スペースも含めて）を書くこと。"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "x"
+    "次の２つケース以外で全角を使うとエラーが発生する。\n",
+    "* 以下で説明する文字列型のデータ型の場合は全角を使っても構わない。\n",
+    "* 半角の`#`の後であれば全角を使っても構わない（`Python`は`#`の後に続くコードを無視するためであり，よくコメントを書くのに使われる）。"
    ]
   },
   {
@@ -82,67 +74,59 @@
     "hidden": true
    },
    "source": [
-    "ここで「代入」に使った`=`について少し説明する。実は、`=`は「代入」ではない。更には、`x`と`10`は別物なのである。これを理解するために、多くの品物が保管されている大きな倉庫を考えてみよう。倉庫の管理者はどの品物がどこに保管されているかを記録する在庫リスト（記録帳やコンピューター・ファイル）を作成し、そこに品物が保管されている棚を示す記号を記入しているとしよう。この例を使うと、"
+    "例えば，次のコード・セルには半角の`10`の後に全角のスペースが紛れ込んでいるためエラーが発生している。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
-    "hidden": true
+    "hidden": true,
+    "tags": [
+     "raises-exception"
+    ]
    },
+   "outputs": [],
    "source": [
-    "* `10`　→　倉庫の棚に保管されている品物\n",
-    "* `x`　→　在庫リストに記載されている棚の記号\n",
-    "\n",
-    "となる。品物と棚の記号は別物なのである。`Python`では、品物である`10`がコンピューター内のメモリーの所定の場所に保存され、その場所を示すのが変数`x`となる。即ち、`x`は品物`10`の実態とは異なる単なる「参照記号」なのである。\n",
-    "* `10`　→　PCのメモリーに保存されている情報\n",
-    "* `x`　→　参照記号\n",
-    "\n",
-    "この点を明確にするために、上のコードは「`x`に`10`を代入する」と考えるのではなく、「`10`を記号`x`に**割り当てる**」と考える。ここで、式を**右から左に**読んでいることに注意しよう。左から右に読んで「記号`x`を`10`に割り当てる」と考えないことを推奨する。意味は同じだが、`=`を右から左に読む（考える）ことを習慣づけることが、今後`Python`を勉強する上で重要となるからである。この点を示すために次のコードを考えてみよう。"
+    "10　"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "x = x + 1"
+    "「全角スペース忍者」には要注意！"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
+    "heading_collapsed": true,
     "hidden": true
    },
    "source": [
-    "「？」と思うかもしれない。暗に方程式として考えるためであろう（私がそうだった）。これを右から左に読むとスッキリする。\n",
-    "1. 一番上のコードで`10`を`x`に割り当てたが、問題のコードの右辺の`x`がその`10`である。`10`に`1`を加えたものが`11`であり、それが右辺である。\n",
-    "1. `=`を使い右辺の`11`を左辺の`x`に割り当てている。この時点で、`10`の参照記号であった`x`は`11`の参照記号に変更される。\n",
-    "\n",
-    "実際に`x`を表示してみよう。"
+    "### 左詰め"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "x"
+    "`Python`ではインデントが重要な役割を果たします。原則，コード・セルの中で左詰めでコードを書くようにすること。一方で，以下で説明するようにインデントが必須な場合（例えば，`for`ループや関数を定義する場合）もあり，その様な場合は**半角スペース4つ**を入れるのが慣例となっている。Jupyter NotebookやJupyterLab (Desktop)では`Tab`を押すことにより半角スペース4つが自動で挿入されるので覚えておこう。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
+    "heading_collapsed": true,
     "hidden": true
    },
    "source": [
-    "この例では、記号`x`は`10`を指していたが`11`に変更されている。これは、同じ記号を複数の「品物」の参照記号に使えないためである。一方で、同じ「品物」を複数の参照記号に割り当てる事は可能である（例えば、`y=x`）。いずれにしろ「品物と参照記号の関係」は今の段階ではそれ程重要ではないが，先に進むにつれて重要性が増してくるので，今のうちにこのようなイメージを持つと良いだろう。"
+    "### 括弧"
    ]
   },
   {
@@ -151,22 +135,17 @@
     "hidden": true
    },
    "source": [
-    "更にもう一点付け加える。`Python`を習うと「オブジェクト」という単語が必ず出てくる。今の内にイメージをつかむために自転車をオブジェクトの例として考えてみよう。通常の自転車には車輪が２つあり、サドルが１つあり、左右にペダルが２つある。これらの数字が自転車に関する**データ**である。またペダルを踏むことにより前に動き、ハンドルを右にきると右方向に進むことになる。即ち、あることを実行すると、ある結果が返されるのである。これは数学の**関数**と同じように理解できる。$y=x^2$の場合、$x$が`2`であれば$y$の値として`4`が返される。このように自転車はデータと関数が備わっているオブジェクトとして考えることができる。また、車輪の数やペダルを踏むことは自転車特有のデータと関数であり、他のオブジェクト（例えば、冷蔵庫）にはない。即ち、世の中の「オブジェクト」にはそれぞれ異なるデータと関数が存在していると考えることができる。\n",
-    "\n",
-    "`Python`の世界でも「すべて」をこれと同じように考え、データを**属性**と呼び、関数を**メソッド**と呼ぶ。上のコードの`10`を例にあげると、単なる数字に見えるが、実は様々な属性とメソッドから構成されるオブジェクトなのである。\n",
-    "1. **属性**（attributes）は`10`が持つ様々なデータ（例えば、`10`という値や整数という情報）\n",
-    "1. **メソッド**（methods）は`10`の特有の関数（例えば、加算、除算のように`10`というデータに働きかける関数）\n",
-    "\n",
-    "自転車と冷蔵庫は異なるデータと関数を持つように、整数`10`と文字列`神戸大学`は異なるデータと関数を備えるオブジェクトなのである。この考え方は`Python`のすべてに当てはまる。即ち、Everything is an object in Python.\n",
-    "\n",
-    "\n",
-    "（メソッドも属性の一種と考えることもできるが、以下では上の分け方に沿って`Python`の使い方を説明する。）"
+    "コードでは括弧が多用されるが，次の呼称とする。\n",
+    "* `()`：丸括弧（parentheses）\n",
+    "* `[]`：角括弧（brackets）\n",
+    "* `{}`：波括弧（braces, curly braces, curly brackets）"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
     "## ４つの基本データ型（Data Types）"
@@ -183,9 +162,14 @@
     "* 整数型（int）\n",
     "* 浮動小数点型（float）\n",
     "* 文字列型（str）\n",
-    "* ブール型（bool）\n",
-    "\n",
-    "整数型とは上の例で使ったもので，"
+    "* ブール型（bool）"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "整数型（`int`）"
    ]
   },
   {
@@ -205,7 +189,7 @@
     "hidden": true
    },
    "source": [
-    "も整数型である。Pythonには様々な関数が用意されており，その１つが`type()`である。それを使うとデータ型を確認できる。"
+    "浮動小数点型（`float`）"
    ]
   },
   {
@@ -216,7 +200,7 @@
    },
    "outputs": [],
    "source": [
-    "type(157)"
+    "3.14"
    ]
   },
   {
@@ -225,16 +209,25 @@
     "hidden": true
    },
    "source": [
-    "`int`はintegerの略で整数型を表す。"
+    "文字列型（`str`）"
    ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "ダブルクォート`\"`もしくはシングルクォート`'`を使う"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "浮動小数点型は"
+    "\"apple\""
    ]
   },
   {
@@ -245,16 +238,25 @@
    },
    "outputs": [],
    "source": [
-    "10.24"
+    "'pear'"
    ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "↓↓↓ も文字列"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "のように小数点がついた数字である。`1`は整数型だが，`1.0`は浮動小数点型となる。"
+    "'100'"
    ]
   },
   {
@@ -263,7 +265,8 @@
     "hidden": true
    },
    "source": [
-    "文字列型はシングルクォート`'`かダブルクォート`\"`の間に文字を入力する。"
+    "ブール型（`bool`）\n",
+    "* 真偽値とも呼ばれる。"
    ]
   },
   {
@@ -274,7 +277,14 @@
    },
    "outputs": [],
    "source": [
-    "\"apple\""
+    "True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`True`は`1`として計算に使うことができる。"
    ]
   },
   {
@@ -285,27 +295,24 @@
    },
    "outputs": [],
    "source": [
-    "'pear'"
+    "False"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "どちらを使っても同じだが，クォートの中でクォートを使う必要がある場合は，それぞれ違ったものを使う。例えば，"
+    "`False`は`0`として計算に使うことができる。"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "'He said \"Good luck!\" to me.'"
+    "## 算術演算子"
    ]
   },
   {
@@ -314,18 +321,22 @@
     "hidden": true
    },
    "source": [
-    "また数字をクォートで囲むと文字列型になる。"
+    "* `+`（加算; addition）\n",
+    "* `-`（減算; subtraction）\n",
+    "* `*`（乗算; multiplication）\n",
+    "* `/`（除算; division）\n",
+    "* `//`（切り捨て除算; 実数の整数部分; floor division）\n",
+    "* `%`（剰余演算; 余りを取得する演算; modulo）\n",
+    "* `**`（累乗; exponentiation）"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "'100'"
+    "加算"
    ]
   },
   {
@@ -336,27 +347,39 @@
    },
    "outputs": [],
    "source": [
-    "type('100')"
+    "10 + 1"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "ブール型（boolean）には`True`（真）, `False`（偽）の２つ（だけ）がある。"
+    "`True`は`1`，`False`は`0`と等しいので次の計算が成立する。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "True"
+    "True + 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "False + 10"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`+`は文字列にも使える。"
    ]
   },
   {
@@ -367,7 +390,7 @@
    },
    "outputs": [],
    "source": [
-    "type(True)"
+    "'I' + ' like' + ' Kobe'"
    ]
   },
   {
@@ -376,7 +399,7 @@
     "hidden": true
    },
    "source": [
-    "ブール型の例として、`1`と`10`の**値**が等しいかどうかを調べるコードを考えてみる。ここで`==`を使うが、`==`を挟んで左右の変数の**値**が正しければ`True`を、間違っていれば`False`が返される。"
+    "減算"
    ]
   },
   {
@@ -387,7 +410,7 @@
    },
    "outputs": [],
    "source": [
-    "1 == 10"
+    "1 - 0.5"
    ]
   },
   {
@@ -396,7 +419,7 @@
     "hidden": true
    },
    "source": [
-    "この結果を変数に割り当てることも可能である。（次のコードでは`()`で`1 == 10`を囲んでるが、読みやすくするためであり、無くてもエラーは出ない。）"
+    "乗算"
    ]
   },
   {
@@ -407,7 +430,16 @@
    },
    "outputs": [],
    "source": [
-    "s = (1 == 10)"
+    "(10 - 2) * 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "hidden": true
+   },
+   "source": [
+    "除算"
    ]
   },
   {
@@ -418,7 +450,7 @@
    },
    "outputs": [],
    "source": [
-    "s"
+    "5 / 2"
    ]
   },
   {
@@ -427,7 +459,8 @@
     "hidden": true
    },
    "source": [
-    "また，`True`は`1`, `False`は`0`として計算される。"
+    "切り捨て除算（floor division） \n",
+    "* 以下では分子・分母が正の値の場合だけを考える"
    ]
   },
   {
@@ -438,18 +471,17 @@
    },
    "outputs": [],
    "source": [
-    "True == 1"
+    "5 // 2 # 5/2=2.5"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "False == 0"
+    "剰余演算\n",
+    "* 以下では分母が正の値の場合だけを考える"
    ]
   },
   {
@@ -460,7 +492,7 @@
    },
    "outputs": [],
    "source": [
-    "True + True"
+    "5 % 2 # 5÷2＝2 余り 1"
    ]
   },
   {
@@ -469,9 +501,7 @@
     "hidden": true
    },
    "source": [
-    "`Python`には「クラス（class）」という概念がある。オブジェクトを生成するための設計図となるもので，この授業で説明はおこなわないが「型（types）」と同義と考えて良い。ちなみにクラス自体もオブジェクトである。\n",
-    "\n",
-    "上のコードでは関数`type()`を使ってデータ型を確認したが，引数を画面上に表示する関数である`print()`を使うとクラス名としてデータ型が表示される。"
+    "累乗"
    ]
   },
   {
@@ -482,29 +512,33 @@
    },
    "outputs": [],
    "source": [
-    "type(10)"
+    "4 ** 2"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "print(type(10))"
+    "## 関係演算子"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "type(10.0)"
+    "* `==`（等号）\n",
+    "* `!=`（等号不成立）\n",
+    "* `<`（小なり）\n",
+    "* `>`（大なり）\n",
+    "* `<=`（小なりイコール）\n",
+    "* `>=`（大なりイコール）\n",
+    "\n",
+    "評価結果として`True`もしくは`False`が返される。"
    ]
   },
   {
@@ -515,7 +549,7 @@
    },
    "outputs": [],
    "source": [
-    "print(type(10.0))"
+    "10 == 10"
    ]
   },
   {
@@ -526,7 +560,7 @@
    },
    "outputs": [],
    "source": [
-    "type('10')"
+    "10 != 10"
    ]
   },
   {
@@ -537,7 +571,7 @@
    },
    "outputs": [],
    "source": [
-    "print(type('10'))"
+    "10 > 5"
    ]
   },
   {
@@ -548,7 +582,7 @@
    },
    "outputs": [],
    "source": [
-    "type(True)"
+    "10>=10"
    ]
   },
   {
@@ -559,49 +593,56 @@
    },
    "outputs": [],
    "source": [
-    "print(type(True))"
+    "10<=10"
    ]
   },
   {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "コードのかなで想定されたデータ型と異なるデータ型を使うとがエラーが出たり，間違った結果につながる場合があるので，自信がない時は`type()`を使って確認すること。\n",
-    "\n",
-    "この他類似する型に`complex type`（複素数型）と`NoneType`も存在する。次の`None`とは「無」という意味である。"
+    "True == 1"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "False == 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "type(None)"
+    "## 理論演算子"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "print(type(None))"
+    "* a & b &nbsp;（aとbの両方） \n",
+    "* a | b &nbsp;&nbsp;（a又はb又は両方）\n",
+    "* ~a &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;（aではない）"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "## コレクション系データ型"
+    "## 割り当て演算子"
    ]
   },
   {
@@ -610,14 +651,9 @@
     "hidden": true
    },
    "source": [
-    "コレクション系とは上で説明した基本データ型の集まりとなるデータ型で，ここでは以下を簡単に説明する。\n",
-    "\n",
-    "* リスト（list）\n",
-    "* タプル（tuple）\n",
-    "* 辞書（dict）\n",
-    "* 集合（set）\n",
+    "* 割り当て演算子（assignment operator）：`=`\n",
     "\n",
-    "リストは`[]`を使う。"
+    "変数$x$に値`10`を「代入」するには等号`=`を使う。"
    ]
   },
   {
@@ -628,8 +664,7 @@
    },
    "outputs": [],
    "source": [
-    "list0 = [10, 3 , 2]\n",
-    "list0"
+    "x = 10"
    ]
   },
   {
@@ -638,7 +673,7 @@
     "hidden": true
    },
    "source": [
-    "以下もリストの一例である。"
+    "また$x$の値を表示すには，次のように$x$を書いたセルを評価するだけである。"
    ]
   },
   {
@@ -649,19 +684,24 @@
    },
    "outputs": [],
    "source": [
-    "list1 = ['A', True, 100]\n",
-    "type(list1)"
+    "x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "１つのセルに複数行で書くと，上から順に実行する。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "print(type(list1))"
+    "x = 10\n",
+    "x"
    ]
   },
   {
@@ -670,7 +710,7 @@
     "hidden": true
    },
    "source": [
-    "上で説明したように、`print()`は定義したリストを画面上に表示する関数であり，`print()`を使うと`list`というクラス（class）であることも確認できる。"
+    "ここで「代入」に使った`=`について少し説明する。実は，`=`は「代入」ではない。更には，`x`と`10`は別物なのである。これを理解するために，多くの品物が保管されている大きな倉庫を考えてみよう。倉庫の管理者はどの品物がどこに保管されているかを記録する在庫リスト（記録帳やコンピューター・ファイル）を作成し，そこに品物が保管されている棚を示す記号を記入しているとしよう。この例を使うと，"
    ]
   },
   {
@@ -679,8 +719,14 @@
     "hidden": true
    },
    "source": [
-    "---\n",
-    "タプルは`()`を使って作成する。"
+    "* `10`　→　倉庫の棚に保管されている品物\n",
+    "* `x`　→　在庫リストに記載されている棚の記号\n",
+    "\n",
+    "となる。品物と棚の記号は別物なのである。`Python`では，品物である`10`がコンピューター内のメモリーの所定の場所に保存され，その場所を示すのが変数`x`となる。即ち，`x`は品物`10`の実態とは異なる単なる「参照記号」なのである。\n",
+    "* `10`　→　PCのメモリーに保存されている情報\n",
+    "* `x`　→　参照記号\n",
+    "\n",
+    "この点を明確にするために，上のコードは「`x`に`10`を代入する」と考えるのではなく，「`10`を記号`x`に**割り当てる**」と考える。ここで，式を**右から左に**読んでいることに注意しよう。左から右に読んで「記号`x`を`10`に割り当てる」と考えないことを推奨する。意味は同じだが，`=`を右から左に読む（考える）ことを習慣づけることが，今後`Python`を勉強する上で重要となるからである。この点を示すために次のコードを考えてみよう。"
    ]
   },
   {
@@ -691,8 +737,7 @@
    },
    "outputs": [],
    "source": [
-    "tuple0 = ('A', True, 100)\n",
-    "print(tuple0)"
+    "x = x + 1"
    ]
   },
   {
@@ -701,16 +746,11 @@
     "hidden": true
    },
    "source": [
-    "リストと変わりないように見えるが，大きな違いは要素を変更できるかできないかという点である。\n",
-    "\n",
-    "* リストの要素は変更可能\n",
-    "* タプルの要素は変更不可能\n",
+    "「？」と思うかもしれない。暗に方程式として考えるためであろう（私がそうだった）。これを右から左に読むとスッキリする。\n",
+    "1. 一番上のコードで`10`を`x`に割り当てたが，問題のコードの右辺の`x`がその`10`である。`10`に`1`を加えたものが`11`であり，それが右辺である。\n",
+    "1. `=`を使い右辺の`11`を左辺の`x`に割り当てている。この時点で，`10`の参照記号であった`x`は`11`の参照記号に変更される。\n",
     "\n",
-    "リストの要素の変更方法は以下で説明する。\n",
-    "\n",
-    "**＜コメント１＞**\n",
-    "\n",
-    "上で通常タプルは`(`と`)`を使って作成できると説明したが、実は、コンマ`,`によってタプルは定義されるため`(`と`)`は必須ではない。例えば、次のコードでもタプルとなる。従って、`(`と`)`はタプルを明確にするためと考えて良い。"
+    "実際に`x`を表示してみよう。"
    ]
   },
   {
@@ -721,53 +761,56 @@
    },
    "outputs": [],
    "source": [
-    "tuple1 = 'B', False, -100"
+    "x"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "print(tuple1)\n",
-    "print(type(tuple1))"
+    "この例では，記号`x`は`10`を指していたが`11`に変更されている。これは，同じ記号を複数の「品物」の参照記号に使えないためである。一方で，同じ「品物」を複数の参照記号に割り当てる事は可能である（例えば，`y=x`）。いずれにしろ「品物と参照記号の関係」は今の段階ではそれ程重要ではないが，先に進むにつれて重要性が増してくるので，今のうちにこのようなイメージを持つと良いだろう。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "**＜コメント２＞**\n",
-    "\n",
-    "１つの要素からなるタプルを作成する場合、コンマ`,`が必ず必要となる。"
+    "## 変数名に使う記号について"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "tuple2 = (10,)"
+    "変数の名前を作る上で守らなくてはならないルールがある。\n",
+    "\n",
+    "* `(a-z, A-Z)`もしくは`_`（アンダースコア）で始める\n",
+    "* 最初の文字以外であれば`(a-z, A-Z)`と`_`に加え数字も可\n",
+    "* 長さに制限はない\n",
+    "* 小文字と大文字は異なる記号としてあつかう\n",
+    "* 次の単語は特定の目的のために事前に定義されているため，変数名としては使えない。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "hidden": true
+    "hidden": true,
+    "tags": [
+     "output_scroll"
+    ]
    },
    "outputs": [],
    "source": [
-    "print(tuple2)\n",
-    "print(type(tuple2))"
+    "import keyword\n",
+    "keyword.kwlist"
    ]
   },
   {
@@ -776,7 +819,13 @@
     "hidden": true
    },
    "source": [
-    "コンマ`,`がないとタプルとはならない。"
+    "これらに加え，\n",
+    "\n",
+    "* 変数の頭文字は小文字とする\n",
+    "\n",
+    "というのが慣例（エラーにはならない）であり，大文字で始まる変数は`class`と呼ばれるオブジェクトに使う。\n",
+    "\n",
+    "また`#`は実行されないコメントを書くときに使われる。以下の例では，`1+2`は実行されるが`#`で始まる行は無視される。"
    ]
   },
   {
@@ -787,19 +836,21 @@
    },
    "outputs": [],
    "source": [
-    "tuple3 = (10)"
+    "# この行はコメント\n",
+    "y = 1 + 2\n",
+    "\n",
+    "# この行もコメント\n",
+    "y   # この箇所もコメント"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "print(tuple3)\n",
-    "print(type(tuple3))"
+    "## コレクション系データ型"
    ]
   },
   {
@@ -808,8 +859,14 @@
     "hidden": true
    },
    "source": [
-    "---\n",
-    "辞書はキー（key）と値（value）のペアとなって定義され，`:`を挟んで１つのペアとなる。全てを`{}`で囲み辞書を定義する。"
+    "コレクション系とは上で説明した基本データ型の集まりとなるデータ型で，ここでは以下を簡単に説明する。\n",
+    "\n",
+    "* リスト（list）\n",
+    "* タプル（tuple）\n",
+    "* 辞書（dict）\n",
+    "* 集合（set）\n",
+    "\n",
+    "リストを作るには`[]`を使う。"
    ]
   },
   {
@@ -820,7 +877,8 @@
    },
    "outputs": [],
    "source": [
-    "dict0 = {'a':10, 'b':'Kobe'}"
+    "lst0 = [10, True , 'apple']\n",
+    "lst0"
    ]
   },
   {
@@ -829,7 +887,7 @@
     "hidden": true
    },
    "source": [
-    "`dict0`には２つのペアがある。`a`のキーには値`10`が対応しており，`b`には`'Kobe'`が設定されている。今の段階では辞書を使う目的が不明確でしっくりこないと思うが，勉強を進めるととてもパワフルなツールだと気づくだろう。"
+    "タプルは`()`を使って作成する。"
    ]
   },
   {
@@ -840,7 +898,26 @@
    },
    "outputs": [],
    "source": [
-    "type(dict0)"
+    "tpl0 = ('A', True, 100)\n",
+    "tpl0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "hidden": true
+   },
+   "source": [
+    "リストと変わりないように見えるが，大きな違いは要素を変更できるかできないかという点である。\n",
+    "\n",
+    "* リストの要素は変更可能\n",
+    "* タプルの要素は変更不可能\n",
+    "\n",
+    "リストの要素の変更方法は以下で説明する。\n",
+    "\n",
+    "**＜コメント＞**\n",
+    "\n",
+    "上で通常タプルは`(`と`)`を使って作成できると説明したが，実は，コンマ`,`によってタプルは定義されるため`(`と`)`は必須ではない。例えば，次のコードでもタプルとなる。従って，`(`と`)`はタプルを明確にするためと考えて良い。"
    ]
   },
   {
@@ -851,7 +928,8 @@
    },
    "outputs": [],
    "source": [
-    "print(type(dict0))"
+    "tpl1 = 'B', False, -100\n",
+    "tpl1"
    ]
   },
   {
@@ -860,16 +938,19 @@
     "hidden": true
    },
    "source": [
-    "集合は使う機会がないので説明は割愛する。"
+    "辞書はキー（key）と値（value）のペアとなって定義され，`:`を挟んで１つのペアとなる。全てを`{}`で囲み辞書を定義する。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
-    "heading_collapsed": true
+    "hidden": true
    },
+   "outputs": [],
    "source": [
-    "## 要素のアクセス方法"
+    "dct0 = {'a':10, 'b':'Kobe'}\n",
+    "dct0"
    ]
   },
   {
@@ -878,7 +959,7 @@
     "hidden": true
    },
    "source": [
-    "まずリストの要素の数え方を説明する。次の図のように左から`0`，`1`，`2`...，右からは`-1`，`-2`，`-3`と数える。"
+    "`dict0`には２つのペアがある。`a`のキーには値`10`が対応しており，`b`には`'Kobe'`が設定されている。今の段階では辞書を使う目的が不明確でしっくりこないと思うが，勉強を進めるととてもパワフルなツールだと気づくだろう。"
    ]
   },
   {
@@ -887,13 +968,7 @@
     "hidden": true
    },
    "source": [
-    "```\n",
-    "   0   1   2   3   4   5  （左から数える） \n",
-    " +---+---+---+---+---+---+\n",
-    " | P | y | t | h | o | n |\n",
-    " +---+---+---+---+---+---+\n",
-    "  -6  -5  -4  -3  -2  -1　（右から数える）\n",
-    "```"
+    "集合は使う機会がないので説明は割愛する。"
    ]
   },
   {
@@ -902,7 +977,14 @@
     "hidden": true
    },
    "source": [
-    "例えば"
+    "コレクション系とは上で説明した基本データ型の集まりとなるデータ型で，ここでは以下を簡単に説明する。\n",
+    "\n",
+    "* リスト（list）\n",
+    "* タプル（tuple）\n",
+    "* 辞書（dict）\n",
+    "* 集合（set）\n",
+    "\n",
+    "リストは`[]`を使う。"
    ]
   },
   {
@@ -913,7 +995,8 @@
    },
    "outputs": [],
    "source": [
-    "my_list = ['A', 'B', 'C', 'D', 'E', 'F']"
+    "list0 = [10, 3 , 2]\n",
+    "list0"
    ]
   },
   {
@@ -922,7 +1005,7 @@
     "hidden": true
    },
    "source": [
-    "の場合，`'A'`は０番目，`'B'`１番目，`'C'`は２番目と数える。例えば，`A`を抽出したい場合，"
+    "以下もリストの一例である。"
    ]
   },
   {
@@ -933,27 +1016,28 @@
    },
    "outputs": [],
    "source": [
-    "my_list[0]"
+    "list1 = ['A', True, 100]\n",
+    "type(list1)"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "最後の要素にアクセスするには次のようにする。"
+    "print(type(list1))"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "my_list[-1]"
+    "上で説明したように，`print()`は定義したリストを画面上に表示する関数であり，`print()`を使うと`list`というクラス（class）であることも確認できる。"
    ]
   },
   {
@@ -962,7 +1046,8 @@
     "hidden": true
    },
    "source": [
-    "連続する複数の要素を選択する場合（スライシング）は`:`を使う。`:`の左側が選択する最初の要素で，`:`の右側が選択する最後の次の番号である（即ち，`:`の右側の番号の要素は含まれない。"
+    "---\n",
+    "タプルは`()`を使って作成する。"
    ]
   },
   {
@@ -973,7 +1058,8 @@
    },
    "outputs": [],
    "source": [
-    "my_list[1:4]"
+    "tuple0 = ('A', True, 100)\n",
+    "print(tuple0)"
    ]
   },
   {
@@ -982,7 +1068,16 @@
     "hidden": true
    },
    "source": [
-    "この例では１番目から3番目を選択している。`:`の左側の番号を省略すると`0`と解釈され，`:`右側を省略すると最後まで全てと解釈される。"
+    "リストと変わりないように見えるが，大きな違いは要素を変更できるかできないかという点である。\n",
+    "\n",
+    "* リストの要素は変更可能\n",
+    "* タプルの要素は変更不可能\n",
+    "\n",
+    "リストの要素の変更方法は以下で説明する。\n",
+    "\n",
+    "**＜コメント１＞**\n",
+    "\n",
+    "上で通常タプルは`(`と`)`を使って作成できると説明したが，実は，コンマ`,`によってタプルは定義されるため`(`と`)`は必須ではない。例えば，次のコードでもタプルとなる。従って，`(`と`)`はタプルを明確にするためと考えて良い。"
    ]
   },
   {
@@ -993,7 +1088,7 @@
    },
    "outputs": [],
    "source": [
-    "my_list[:4]"
+    "tuple1 = 'B', False, -100"
    ]
   },
   {
@@ -1004,7 +1099,8 @@
    },
    "outputs": [],
    "source": [
-    "my_list[1:]"
+    "print(tuple1)\n",
+    "print(type(tuple1))"
    ]
   },
   {
@@ -1013,7 +1109,9 @@
     "hidden": true
    },
    "source": [
-    "タプルも同じように選択でる。"
+    "**＜コメント２＞**\n",
+    "\n",
+    "１つの要素からなるタプルを作成する場合，コンマ`,`が必ず必要となる。"
    ]
   },
   {
@@ -1024,7 +1122,7 @@
    },
    "outputs": [],
    "source": [
-    "my_tuple = ('A', 'B', 'C', 'D', 'E', 'F')"
+    "tuple2 = (10,)"
    ]
   },
   {
@@ -1035,18 +1133,17 @@
    },
    "outputs": [],
    "source": [
-    "my_tuple[2]"
+    "print(tuple2)\n",
+    "print(type(tuple2))"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "my_tuple[:3]"
+    "コンマ`,`がないとタプルとはならない。"
    ]
   },
   {
@@ -1057,27 +1154,29 @@
    },
    "outputs": [],
    "source": [
-    "my_tuple[2:]"
+    "tuple3 = (10)"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "文字列も同じ方法でアクセスできる。"
+    "print(tuple3)\n",
+    "print(type(tuple3))"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "my_text = 'University'"
+    "---\n",
+    "辞書はキー（key）と値（value）のペアとなって定義され，`:`を挟んで１つのペアとなる。全てを`{}`で囲み辞書を定義する。"
    ]
   },
   {
@@ -1088,7 +1187,7 @@
    },
    "outputs": [],
    "source": [
-    "my_text[1:4]"
+    "dict0 = {'a':10, 'b':'Kobe'}"
    ]
   },
   {
@@ -1097,7 +1196,7 @@
     "hidden": true
    },
    "source": [
-    "辞書の場合はキーで指定する。複数指定する場合は，`for loop`などの複雑な手法が必要となる。"
+    "`dict0`には２つのペアがある。`a`のキーには値`10`が対応しており，`b`には`'Kobe'`が設定されている。今の段階では辞書を使う目的が不明確でしっくりこないと思うが，勉強を進めるととてもパワフルなツールだと気づくだろう。"
    ]
   },
   {
@@ -1108,7 +1207,7 @@
    },
    "outputs": [],
    "source": [
-    "my_dict = {'a':10, 'b':'apple', 'c':[1,2,5]}"
+    "type(dict0)"
    ]
   },
   {
@@ -1119,18 +1218,16 @@
    },
    "outputs": [],
    "source": [
-    "my_dict['a']"
+    "print(type(dict0))"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "my_dict['c']"
+    "集合は使う機会がないので説明は割愛する。"
    ]
   },
   {
@@ -1139,37 +1236,23 @@
     "heading_collapsed": true
    },
    "source": [
-    "## 変数名に使う記号について"
+    "## 要素の抽出方法"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "上の例では`my_list`など好きなアルファベットの組み合わせを使いわかりやすい変数名にしている。しかし，変数の名前を作る上で守らなくてはならないルールがある。\n",
-    "\n",
-    "* `(a-z, A-Z)`もしくは`_`（アンダースコア）で始める\n",
-    "* 最初の文字以外であれば`(a-z, A-Z)`と`_`に加え数字も可\n",
-    "* 長さに制限はない\n",
-    "* 小文字と大文字は異なる記号としてあつかう\n",
-    "* 次の単語は特定の目的のために事前に定義されているため，変数名としては使えない。"
+    "### 各要素の抽出"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true,
-    "tags": [
-     "output_scroll"
-    ]
+    "hidden": true
    },
-   "outputs": [],
    "source": [
-    "import keyword\n",
-    "keyword.kwlist"
+    "まずリストの要素の数え方を説明する。次の図のように左から`0`，`1`，`2`...，右からは`-1`，`-2`，`-3`と数える。"
    ]
   },
   {
@@ -1178,13 +1261,13 @@
     "hidden": true
    },
    "source": [
-    "これらに加え，\n",
-    "\n",
-    "* 変数の頭文字は小文字とする\n",
-    "\n",
-    "というのが慣例（エラーにはならない）であり，大文字で始まる変数は`class`と呼ばれるオブジェクトに使う。\n",
-    "\n",
-    "また`#`は実行されないコメントを書くときに使われる。以下の例では，`1+2`は実行されるが`#`で始まる行は無視される。"
+    "```\n",
+    "   0   1   2   3   4   5  （左から数える） \n",
+    " +---+---+---+---+---+---+\n",
+    " | A | B | C | D | E | F |\n",
+    " +---+---+---+---+---+---+\n",
+    "  -6  -5  -4  -3  -2  -1　（右から数える）\n",
+    "```"
    ]
   },
   {
@@ -1195,52 +1278,46 @@
    },
    "outputs": [],
    "source": [
-    "# この行はコメント\n",
-    "1+2"
+    "lst1 = ['A', 'B', 'C', 'D', 'E', 'F']"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true
+    "hidden": true
    },
    "source": [
-    "## 算術演算子"
+    "の場合，`'A'`は`0`番目，`'B'`は`1`番目，`'C'`は`2`番目と数える。ここでの，`0`，`1`，`1`を**インデックス**（index）と呼ぶ。"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "* `+`（加算; addition）\n",
-    "* `-`（減算; subtraction）\n",
-    "* `*`（乗算; multiplication）\n",
-    "* `/`（除算; division）\n",
-    "* `//`（切り捨て除算; 実数の整数部分; floor division）\n",
-    "* `%`（剰余演算; 余りを取得する演算; modulo）\n",
-    "* `**`（累乗; exponentiation）"
+    "要素のアクセス方法：\n",
+    "* `[]`とインデックス番号を使う。\n",
+    "\n",
+    "例えば，`A`を抽出したい場合，"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "加算（addition）"
+    "lst1[0]"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "type(1+1)"
+    "最後の要素にアクセスするには次のようにする。"
    ]
   },
   {
@@ -1251,29 +1328,29 @@
    },
    "outputs": [],
    "source": [
-    "type(1+1.0)"
+    "lst1[-1]"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "'I' + 'like' + 'Kobe'"
+    "### 連続する複数の要素の抽出"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "'I' + ' like' + ' Kobe'"
+    "連続する複数の要素を選択する場合（スライシング）は`:`を使う。\n",
+    "* `:`の左側が選択する最初の要素\n",
+    "* `:`の右側が選択する最後の**次の**番号\n",
+    "\n",
+    "`B`（1番目），`C`と`D`（3番目）を抽出したい場合を考えよう。"
    ]
   },
   {
@@ -1284,27 +1361,23 @@
    },
    "outputs": [],
    "source": [
-    "[1, 2] + ['apple']"
+    "lst1[1:4]"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "減算（division）"
+    "次のように書くとより直観的かもしれない。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "1-0.5"
+    "lst1[1:3+1]"
    ]
   },
   {
@@ -1313,7 +1386,9 @@
     "hidden": true
    },
    "source": [
-    "乗算（multiplication）"
+    "次のルールも覚えておこう：\n",
+    "* `:`の左側の番号を省略すると「最初から全て」となる。\n",
+    "* `:`の右側を省略すると「最後まで全て」となる。"
    ]
   },
   {
@@ -1324,7 +1399,7 @@
    },
    "outputs": [],
    "source": [
-    "type(2*2)"
+    "lst1[:4]"
    ]
   },
   {
@@ -1335,18 +1410,16 @@
    },
    "outputs": [],
    "source": [
-    "type(2*2.0)"
+    "lst1[1:]"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "[1,2,3]*3"
+    "### タプルも同じ"
    ]
   },
   {
@@ -1355,7 +1428,7 @@
     "hidden": true
    },
    "source": [
-    "除算（division）"
+    "タプルも同じ方法で要素を抽出できる。"
    ]
   },
   {
@@ -1366,17 +1439,18 @@
    },
    "outputs": [],
    "source": [
-    "type(10/5)"
+    "tpl1 = ('A', 'B', 'C', 'D', 'E', 'F')"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "切り捨て除算（floor division） \n",
-    "* 以下では分子・分母が正の値の場合だけを考える"
+    "tpl1[2]"
    ]
   },
   {
@@ -1387,48 +1461,45 @@
    },
    "outputs": [],
    "source": [
-    "5//2 # 5/2=2.5"
+    "tpl1[1:3+1]"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "剰余演算（modulo）\n",
-    "* 以下では分母が正の値の場合だけを考える"
+    "### 文字列も同じ"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "5%2 # 5÷2＝2 余り 1"
+    "文字列も同じ方法で要素を抽出できる。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "累乗（exponentiation）"
+    "str0 = 'University'"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "type(2**2)"
+    "str0[3]"
    ]
   },
   {
@@ -1439,16 +1510,14 @@
    },
    "outputs": [],
    "source": [
-    "type(2**2.0)"
+    "str0[1:3+1]"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "heading_collapsed": true
-   },
+   "metadata": {},
    "source": [
-    "## 関係演算子"
+    "### 辞書は異なる"
    ]
   },
   {
@@ -1457,12 +1526,7 @@
     "hidden": true
    },
    "source": [
-    "* `==`（等号）\n",
-    "* `!=`（等号不成立）\n",
-    "* `<`（小なり）\n",
-    "* `>`（大なり）\n",
-    "* `<=`（小なりイコール）\n",
-    "* `>=`（大なりイコール）"
+    "辞書の場合はキーで指定する。"
    ]
   },
   {
@@ -1473,7 +1537,7 @@
    },
    "outputs": [],
    "source": [
-    "10 == 10"
+    "dct1 = {'a':10, 'b':'apple', 'c':[1,2,5]}"
    ]
   },
   {
@@ -1484,7 +1548,7 @@
    },
    "outputs": [],
    "source": [
-    "10 != 10"
+    "dct1['a']"
    ]
   },
   {
@@ -1495,159 +1559,347 @@
    },
    "outputs": [],
    "source": [
-    "10 > 5"
+    "dct1['c']"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "複数指定する場合は，`for loop`などの複雑な手法が必要となる。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
+   "source": [
+    "## 要素の入れ替え"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "### リストの場合"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "上で作成した`lst1`を考えよう。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "10>=10"
+    "lst1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`2`番目にある`C`を`100`に入れ替えたい場合，次のようにする。\n",
+    "* `=`を使う。\n",
+    "* `=`の左側に`C`を抽出するコードを書く。\n",
+    "* `=`の右側に`100`を書く。\n",
+    "\n",
+    "コードを書いてみよう。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "10<=10"
+    "lst1[2] = 100"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst1"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "## 理論演算子"
+    "### タプルと文字列の場合"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "タプルと文字列は変更不可であるため，要素の入れ替えはできない。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "* a & b &nbsp;（aとbの両方） \n",
-    "* a | b &nbsp;&nbsp;（a又はb又は両方）\n",
-    "* ~a &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;（aではない）"
+    "### 辞書の場合"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "上で作成した`dct1`を考えよう。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dct1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`apple`を`pear`に入れ替えたい場合，次のようにする。\n",
+    "* `=`を使う。\n",
+    "* `=`の左側に`apple`を抽出するコードを書く。\n",
+    "* `=`の右側に`pear`を書く。\n",
+    "\n",
+    "コードを書いてみよう。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dct1['b'] = 'pear'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dct1"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "## if 文"
+    "## 要素の追加"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "`if`文を使うと，あるブール型（真偽）の条件のもとでコードを実行することが可能となる。例えば，`X`の値が正の場合，\n",
-    "\n",
-    "`print(X, 'は正です')`\n",
-    "\n",
-    "を実行したいとしよう。"
+    "### リストの場合"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "上で作成した`lst1`を考えよう。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "X = 10"
+    "lst1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "最後に`3.14`を追加したい場合，メソッド`.append()`を使う。メソッドについては，以下でより詳しく説明するので，ここではコードだけを紹介する。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst1.append(3.14)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "if X > 0:\n",
-    "    print(X, 'は正です')\n",
-    "else:\n",
-    "    pass"
+    "### タプルの場合"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "変更不可なので，要素の追加はできない。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "＜注意点＞\n",
-    ">* `if`と`else` で始まる条件を示す行の最後は`:`となる。入れ忘れるとエラーとなる。\n",
-    ">* `print()`の行は４つの半角スペースのインデントを入れること。（半角スペースが入っていれば、スペースの数は関係なしにエラーは発生しい。しかし可読性向上のために４つの半角スペースを使うことが慣例となっている。）\n",
-    ">* `else`とは「`X>0`以外の場合」という意味。\n",
-    ">* `pass`は「何もしない」という意味。\n",
-    "\n",
-    "ここで`else`以下を省略してもエラーにはならない（結果も変わらない）。即ち，`else`以下がない場合は，それが省略されていると考えれば良い。"
+    "### 文字列"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "次の文字列を考えよう。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "X = -1"
+    "moji = 'Kobe'\n",
+    "moji"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "` Univ`を追加する場合，`+`を使うことができる。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "moji = moji + ' Univ'\n",
+    "moji"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
+   "source": [
+    "### 辞書の場合"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "上で作成した`dct1`を考えよう。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "if X > 0:\n",
-    "    print(X, 'は正です')\n",
-    "else:\n",
-    "    pass"
+    "dct1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "新たな要素`d:3.14`を追加したい場合，次のようにする。\n",
+    "* `=`を使う。\n",
+    "* `=`の左側に，あたかも`d`を抽出するようなコードを書く。\n",
+    "* `=`の右側に`3.14`を書く。\n",
+    "\n",
+    "コードを書いてみよう。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dct1['d'] = 3.14"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dct1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "if X > 0:\n",
-    "    print(X, 'は正です')"
+    "## 組み込み関数"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`Python`が起動すると，直ぐに使えるように様々な関数が用意されており組み込み関数（built-in functions）と呼ばれる。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "両方とも何も表示されない。\n",
-    "\n",
-    "---"
+    "### `print()`"
    ]
   },
   {
@@ -1656,13 +1908,7 @@
     "hidden": true
    },
    "source": [
-    "次に，複数の条件を導入するために次の３つ`print`関数を使おう。\n",
-    "\n",
-    "1. `print(X, 'は正です')`\n",
-    "1. `print(X, 'はゼロです')`\n",
-    "1. `print(X, 'は負です')`\n",
-    "\n",
-    "`X`の値が正の場合は`1`を，ゼロの場合は`2`を，負の場合は`3`を表示したいとしよう。"
+    "`print()`は表示するための関数であり，引数に表示したい値を置く。Jupyter Notebookでは`print()`を使わなくとも出力が表示される。例えば，"
    ]
   },
   {
@@ -1673,7 +1919,16 @@
    },
    "outputs": [],
    "source": [
-    "X = -1"
+    "10"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "hidden": true
+   },
+   "source": [
+    "しかし複数行の場合は最後の行しか表示されない。"
    ]
   },
   {
@@ -1684,12 +1939,8 @@
    },
    "outputs": [],
    "source": [
-    "if X == 0:\n",
-    "    print(X, 'はゼロです。')\n",
-    "elif X > 0:\n",
-    "    print(X, 'は正です。')\n",
-    "else:\n",
-    "    print(X, 'は負です。')"
+    "10\n",
+    "200"
    ]
   },
   {
@@ -1698,21 +1949,19 @@
     "hidden": true
    },
    "source": [
-    "注意点\n",
-    "* `if`, `elif`, `else` で始まる条件を示す行の最後は`:`となる。入れ忘れるとエラーとなる。\n",
-    "* `print()`の行は４つの半角スペースのインデントが入る。\n",
-    "* `else`の行に`X<0`は不要（残りの可能性は`X<0`しかないため）\n",
-    "* `elif`は`else if`の省略形であり，２つ目の条件を定義する。\n",
-    "* `elif`は`if`と`else`の間に複数入れることが可能"
+    "`print()`を使うと両方を表示することができる。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
-    "heading_collapsed": true
+    "hidden": true
    },
+   "outputs": [],
    "source": [
-    "## for ループと内包表記"
+    "print(10)\n",
+    "print(200)"
    ]
   },
   {
@@ -1721,7 +1970,7 @@
     "hidden": true
    },
    "source": [
-    "`for`ループは同じコードを複数回リピートして実行したい場合に有効な方法である。例えば，次のリストにある名前を表示したいとしよう。"
+    "異なるオブジェクトを表示するには`,`を使う。"
    ]
   },
   {
@@ -1732,7 +1981,16 @@
    },
    "outputs": [],
    "source": [
-    "name_list = ['太郎', '次郎', '三郎', '四郎', '五郎']"
+    "print('2020年の実質GDP：約', 500+25.7, '兆円')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "hidden": true
+   },
+   "source": [
+    "文字列の中で`\\n`は改行を示す。"
    ]
   },
   {
@@ -1743,8 +2001,7 @@
    },
    "outputs": [],
    "source": [
-    "for name in name_list:\n",
-    "    print(name)"
+    "print('マクロ\\n経済学')"
    ]
   },
   {
@@ -1753,15 +2010,7 @@
     "hidden": true
    },
    "source": [
-    "説明と注意点\n",
-    "* `for`がある一行目は`:`で終わる。\n",
-    "* `name`は`name_list`にあるそれぞれの要素を示すダミー記号。`name`ではなく`i`や`s`など使いやすい記号を使って構わない。\n",
-    "* `name_list`にある要素を最初から一つずつ実行する。\n",
-    "* 2行目は4つの半角スペースを使ってインデントしている。\n",
-    "\n",
-    "`for`ループでよく使うパターンして次の例を考える。この例では，リストに要素を追加する`.append()`を使うが，これについては以下でより詳しく説明する。\n",
-    "\n",
-    "まず次のリストを定義する。"
+    "次に`f-string`（formatted string literal; フォーマット済み文字列リテラル）を紹介する。文字列の前に`f`を書き加え，文字列の中で`{}`を使うことにより，割り当てた変数の値や計算結果などを表示することが可能となる。次の例を考えよう。"
    ]
   },
   {
@@ -1772,7 +2021,9 @@
    },
    "outputs": [],
    "source": [
-    "var_list = [1,2,3,4,5]"
+    "x = 2/3\n",
+    "\n",
+    "print(f'3分の2は{x}です。')"
    ]
   },
   {
@@ -1781,7 +2032,7 @@
     "hidden": true
    },
    "source": [
-    "それぞれの要素の2倍からなるリストを作成したいとしよう。"
+    "**四捨五入**し小数点第３位まで表示する場合は，`x`の後に`:.3f`を付け加える。"
    ]
   },
   {
@@ -1792,10 +2043,7 @@
    },
    "outputs": [],
    "source": [
-    "my_list = []  # 1\n",
-    "\n",
-    "for i in var_list:  # 2\n",
-    "    my_list.append(2*i)  # 3"
+    "print(f'3分の2は約{x:.3f}です。')"
    ]
   },
   {
@@ -1804,78 +2052,226 @@
     "hidden": true
    },
    "source": [
-    "このループの考え方：\n",
-    "\n",
-    "1. 空のリストの作成（ここに2倍にした数字を格納する）\n",
-    "1. ここから`for`ループの始まりとなる。`i`はループを回していく際に`[1,2,3,4,5]`の要素を割り当てる変数である。`var_list`には５つの要素があるので５回同じ作業を繰り返す。１回目のループでは，`var_list`の0番目の要素`1`を`i`に割り当てる事になる。次の行に進んで，その行の評価が終わると２回目のループが始まり，`var_list`の1番目の要素`2`を`i`に割り当てる。そして次の行に進み，その評価が終わると３回目のループが始まり，同じ作業が続く。ループは５回目で終わることになる。\n",
-    "1. `.append()`は`2*i`を`my_list`に追加するリストのメソッド（関数と同義であり，後ほど違いを説明する）であり，この行が評価される毎に`my_list`に`2*i`が追加されて行くことになる。\n",
+    "＜`:.3f`の解釈＞\n",
+    "* `:`はこの後に続くコードは表示に関するものだと「宣言」している。\n",
+    "* `.`は小数点表示に関しての設定であることを示している。\n",
+    "* `3`は小数点第３位を示している。\n",
+    "* `f`は`float`の`f`\n",
     "\n",
-    "このように，`for`ループとは上のコードの２〜３を５回繰り返している。`my_list`を表示しよう。"
+    "`3f`を`5f`にすると，小数点第５位までの四捨五入となる。試してみよう。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "### `sum()`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "合計を返す関数"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = [1, 2, 3, 4, 5, 6]\n",
+    "\n",
+    "sum(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
+   "source": [
+    "### `len()`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "要素数を返す関数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`x`の平均は次のように計算できる。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "print(my_list)"
+    "sum(x) / len(x)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "```{note}\n",
-    "上の例では`for`ループの１行目に**リスト**を使って（`name_list`や`var_list`），`0`番目の要素から順に関数・メソッドを使った。これはリストが要素を１つずつ返すことができる反復可能なオブジェクトであるため可能となる。そのようなオブジェクトは**iterable`と呼ばれ，タプルや文字列，そして後で説明する`Numpy`の`array`も含まれる。\n",
-    "```"
+    "### `abs()`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "絶対値を返す関数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "abs(-10)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "次の例では文字列を一文字ずつ表示する。"
+    "### `range()`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "等差数列のオブジェクトを用意する関数\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": {},
+   "outputs": [],
+   "source": [
+    "range(10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "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`ループではよく使う関数なので覚えておこう！"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
+   "source": [
+    "### `list()`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "リストを作成する関数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "z = range(10)\n",
+    "\n",
+    "list(z)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`range(10)`で準備された`0`から`9`までの整数を使って，リストを作成している。次のコードを実行すると10億個の整数からなるリストを作成することができる。アンコメントして（`# `を削除して）実行すると、終了まで数分掛かるだろう！You are warned!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "my_string = 'Kobe'    # 文字列を作成しmy_stringに割り当てる\n",
-    "\n",
-    "for s in my_string:   # forループの開始\n",
-    "    print(s)          # 文字を表示"
+    "# list( range(1_000_000_000) )"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "上で使った例では，3行のコードを書き`for`ループを使いリストを作成した。内包表記（list comprehension）を使うと同じ結果を1行のコード（one linerと呼ばれる）で得ることもできる。例として`var_list`の要素を2倍にする`for`ループをもう一度考えてみる。"
+    "## ユーザー定義関数"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "[2*i for i in var_list]"
+    "### 最も簡単な例"
    ]
   },
   {
@@ -1884,19 +2280,9 @@
     "hidden": true
    },
    "source": [
-    "色分けすると，上の`for`ループと内包表記は以下のような対応関係にある。\n",
+    "組み込み関数以外に，ユーザーは自由に関数を作成することができる。コードを書くうえでユーザー定義関数は非常に重要な役割を果たす。\n",
     "\n",
-    "`for`ループ\n",
-    "<pre>\n",
-    "<font color=blue>my_list</font> = []\n",
-    "<font color=red>for i in val_list</font>:\n",
-    "    <font color=blue>my_list</font>.append(<font color=green>expression</font>)\n",
-    "</pre>\n",
-    "\n",
-    "内包表記\n",
-    "<pre>\n",
-    "<font color=blue>my_list</font> = [<font color=green>expression</font> <font color=red>for i in val_list</font>]\n",
-    "</pre>"
+    "関数には引数が設定されるが（省略される場合もある），複数の種類がある。ここでは基本となる引数のみを考えるが，引数の**位置**と`=`が重要な役割を果たすことになる。"
    ]
   },
   {
@@ -1905,7 +2291,7 @@
     "hidden": true
    },
    "source": [
-    "`for`ループに`if`文を組み込むことができる。次の例では，`var_list`の数字が偶数であれば2倍にして新たなリストを作成する。"
+    "最初の例は数字の2乗を計算する関数である。"
    ]
   },
   {
@@ -1916,15 +2302,9 @@
    },
    "outputs": [],
    "source": [
-    "my_list = []    # 空のリストの作成\n",
-    "\n",
-    "for i in var_list:            # forループの開始\n",
+    "def squared(x):\n",
     "    \n",
-    "    if i % 2 ==0:             # 余りが０の場合\n",
-    "        my_list.append(2*i)   # 二乗してmy_listに追加する\n",
-    "                              # 余りが０でない場合はpass\n",
-    "        \n",
-    "print(my_list)    # my_listの表示"
+    "    return x**2"
    ]
   },
   {
@@ -1933,7 +2313,15 @@
     "hidden": true
    },
    "source": [
-    "上の例を内包表記にすることも可能である。"
+    "説明：\n",
+    "* １行目：\n",
+    "    * `def`で始まり（`def`はdefinitionの省略形）`:`で終わる。\n",
+    "    * `squared`が関数名，`x`が第１引数（ひきすう）であり唯一の引数である。\n",
+    "* ２行目：\n",
+    "    * `return`は評価した値を「返す」もしくは「戻す」という意味。`return`の前には4つの半角スペースが必要である。\n",
+    "    * `x**2`という返り値（戻り値）の設定をする\n",
+    "\n",
+    "関数を評価するには，引数に数字を入れて実行する。"
    ]
   },
   {
@@ -1944,7 +2332,7 @@
    },
    "outputs": [],
    "source": [
-    "[2*i for i in var_list if i % 2 == 0]"
+    "squared(2)"
    ]
   },
   {
@@ -1953,7 +2341,13 @@
     "hidden": true
    },
    "source": [
-    "改行を入れるとより分かりやすくなる。"
+    "（注意）\n",
+    "* 関数を定義する場合の引数（上の例では`x`)は「仮引数」（parameter）と呼ぶ。\n",
+    "* 関数を評価する際に関数に引き渡す引数（上の例では`2`）は「実引数」（argument）と呼ぶ。\n",
+    "* 以下では両方を「引数」と呼ぶ。\n",
+    "\n",
+    "---\n",
+    "引数が無い関数を定義することを可能である。"
    ]
   },
   {
@@ -1964,11 +2358,23 @@
    },
    "outputs": [],
    "source": [
-    "# コード１\n",
+    "def func_kobe():\n",
+    "    \n",
+    "    return 'I love Kobe :)'\n",
+    "    \n",
     "\n",
-    "[2*i\n",
-    " for i in var_list\n",
-    " if i % 2 == 0]"
+    "func_kobe()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "heading_collapsed": true,
+    "hidden": true,
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "### 引数の位置が重要"
    ]
   },
   {
@@ -1977,7 +2383,7 @@
     "hidden": true
    },
    "source": [
-    "次の例では偶数を10倍にし，奇数を1/10にしている。"
+    "上の例では引数が１つしかないが，引数が複数ある場合にその位置が重要になってくる。次の例を考えよう。"
    ]
   },
   {
@@ -1988,52 +2394,40 @@
    },
    "outputs": [],
    "source": [
-    "my_list = []    # 空のリストの作成\n",
-    "\n",
-    "for i in var_list:    # forループの開始\n",
+    "def division(a, b):\n",
     "    \n",
-    "    if i % 2 ==0:     # 余りが０の場合\n",
-    "        x = 10*i      # 10倍にしてxに割り当てる\n",
-    "    else:             # 余りが０でない場合\n",
-    "        x = i/10      # 10分の１にしてxに割り当てる\n",
-    "        \n",
-    "    my_list.append(x) # xをmy_listに追加\n",
-    "        \n",
-    "print(my_list)    # my_listの表示"
+    "    return a / b"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "内包表記を使うと次のようになる。"
+    "division(10, 2)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "# コード２\n",
-    "\n",
-    "[10*i\n",
-    " if i%2 == 0\n",
-    " else i/10\n",
-    " for i in var_list]"
+    "`a`が第1引数，`b`が第2引数である。引数の順番を間違えると意図しない結果につながる。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "コード１とコード２で`if`文の位置が異なることに注意しよう。コード１では`if`文は`for`の後にくるが，コード２では`for`の前に来ている。"
+    "division(2, 10)"
    ]
   },
   {
@@ -2042,7 +2436,7 @@
     "hidden": true
    },
    "source": [
-    "内包表記の応用例として，次のリストの要素抽出について考えてみよう。"
+    "もちろん，3つ以上の位置引数も設定可能である。"
    ]
   },
   {
@@ -2053,27 +2447,31 @@
    },
    "outputs": [],
    "source": [
-    "lst = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19] "
+    "def my_func(a, b, c, d):\n",
+    "    \n",
+    "    return (a - b) / (c + d)"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "新たに`0`，`2`, `7`, `9`番目の要素からなるリストを作成したいとする。この場合,"
+    "my_func(10, 20, 30, 40)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "hidden": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "[lst[0],lst[2],lst[7],lst[9]]"
+    "### 実行する際に`=`を使う"
    ]
   },
   {
@@ -2082,7 +2480,7 @@
     "hidden": true
    },
    "source": [
-    "とすることも可能だが，内包表記を使うと次のコードになる。"
+    "**関数を実行する際**に，引数に`=`を使って値を指定することも可能である。"
    ]
   },
   {
@@ -2093,8 +2491,7 @@
    },
    "outputs": [],
    "source": [
-    "idx = [0,2,7,9]\n",
-    "[lst[i] for i in idx]"
+    "division(a=10, b=2)"
    ]
   },
   {
@@ -2103,16 +2500,18 @@
     "hidden": true
    },
    "source": [
-    "何番目の要素にアクセスしているのかは`idx`で確かめる方が見やすい事がわかる。"
+    "この場合，引数の順番を変えることが可能となる。それが関数を実行する際に`=`を使う利点である。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
-    "heading_collapsed": true
+    "hidden": true
    },
+   "outputs": [],
    "source": [
-    "## while ループ"
+    "division(b=2, a=10)"
    ]
   },
   {
@@ -2121,76 +2520,60 @@
     "hidden": true
    },
    "source": [
-    "`for`ループと同様，`while`ループもコードを複数回実行したい場合に使う。２つは以下の点で違いがある。\n",
-    "\n",
-    "* `for`ループは与えられたリストなどのiterableの要素数の数だけループが実行される。\n",
-    "* `while`ループはある条件が満たされるまでループが実行される。\n",
-    "\n",
-    "例として，上で定義した`name_list`を表示するループを考える。"
+    "この場合，全ての引数に`=`を使わないとエラーとなる。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "hidden": true
+    "hidden": true,
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": [
-    "i = 0 #　iの値を0に設定"
+    "division(10, a=2)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "while i <= 4:\n",
-    "    print(name_list[i])\n",
-    "    i = i + 1"
+    "理由は最初の`10`を`a`の値と解釈されるためである。一方で，引数の位置が揃っていれば，全ての引数に`=`を付ける必要はない。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "説明と注意点\n",
-    "* `while`がある一行目は`:`で終わる。\n",
-    "* `i`は条件を表すカウンターの役割と`name_list`の要素のインデックスの役割がある\n",
-    "* １行目の意味：$i<=4$の条件が満たされ散る限り，下に続くコードを反復実行する（タイプする文字数を少なくするために$i<5$と書く場合が多い\n",
-    "* ２行目の意味：`name_list`の`i`番目の要素を表示\n",
-    "* ３行目の意味：カウンター`i`の値を`1`増やす\n",
-    "    * 先に右辺を評価した後，それを左辺の`i`に割り当てる考える。（方程式としては考えない!）\n",
-    "* ２行目と３行目は４つの半角スペースがインデントとして入る。\n",
-    "* `while`ループは無限ループになる場合があるので注意しよう。"
+    "my_func(10, 20, d=40, c=30)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true
+    "hidden": true
    },
    "source": [
-    "## 関数"
+    "ここでも引数の位置が重要な役割を果たしている。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "hidden": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "コードを書くうえで関数は非常に重要な役割を果たす。Pythonには組み込み関数（事前に準備された関数; built-in functions）が数多くあり，上で使った`print()`と`type()`\n",
-    "も組み込み関数である。組み込み関数は様々なものが存在するが、ここではプログラマー自身が作成する関数について説明する。\n",
-    "\n",
-    "（注意）\n",
-    "\n",
-    "関数には引数が設定されるが（省略される場合もある）、複数の種類がある。ここでは基本となる引数のみを考えるが，引数の**位置**と`=`が重要な役割を果たすことになる。"
+    "### 定義する際に`=`を使う"
    ]
   },
   {
@@ -2199,7 +2582,7 @@
     "hidden": true
    },
    "source": [
-    "最初の例は数字の2乗を計算する関数である。"
+    "**関数を定義する際**，`=`を使って引数のデフォルトの値を設定することができる。即ち，引数を入力すると入力された数値を使うが，引数を入力しない場合は引数を予め設定した値（デフォルトの値）が使われて評価される。次の例では`c`のデフォルトの値が`10`に設定されている。"
    ]
   },
   {
@@ -2210,8 +2593,9 @@
    },
    "outputs": [],
    "source": [
-    "def func_0(x):\n",
-    "    return x**2"
+    "def another_func(a, b, c=10):\n",
+    "    \n",
+    "    return (a + b) * c"
    ]
   },
   {
@@ -2220,15 +2604,7 @@
     "hidden": true
    },
    "source": [
-    "説明：\n",
-    "* １行目：\n",
-    "    * `def`で始まり（`def`はdefinitionの省略形）`:`で終わる。\n",
-    "    * `func_0`が関数名，`x`が第１引数（ひきすう）であり唯一の引数である。\n",
-    "* ２行目：\n",
-    "    * `return`は評価した値を「返す」という意味。必ず`return`の前には4つの半角スペースが必要である。\n",
-    "    * `x**2`という返り値（戻り値）の設定をする\n",
-    "\n",
-    "関数を評価するには，引数に数字を入れて実行する。"
+    "`c`の値を与えずに評価してみる。"
    ]
   },
   {
@@ -2239,7 +2615,7 @@
    },
    "outputs": [],
    "source": [
-    "func_0(2)"
+    "another_func(2, 3)"
    ]
   },
   {
@@ -2248,13 +2624,7 @@
     "hidden": true
    },
    "source": [
-    "（注意）\n",
-    "* 関数を定義する場合の引数（上の例では`x`)は「仮引数」（parameter）と呼ぶ。\n",
-    "* 関数を評価する際に関数に引き渡す引数（上の例では`2`）は「実引数」（argument）と呼ぶ。\n",
-    "* 本書では両方を「引数」と呼んでいる。\n",
-    "\n",
-    "---\n",
-    "引数が無い関数を定義することを可能である。"
+    "次に`c`にデフォルトと異なる値を設定してみる。"
    ]
   },
   {
@@ -2265,94 +2635,94 @@
    },
    "outputs": [],
    "source": [
-    "def func_kobe():\n",
-    "    return 'I love Kobe :)'\n",
-    "    \n",
-    "\n",
-    "func_kobe()"
+    "another_func(2, 3, 100)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true,
     "hidden": true
    },
    "source": [
-    "### 引数の位置が重要なケース"
+    "（Note）\n",
+    "* 関数を実行する際に`=`無しで関数に渡される引数は，その位置が重要であるため「位置引数」と呼ばれる。\n",
+    "* 関数を実行する際に`=`付きで関数に渡される引数は「キーワード引数」と呼ばれる。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "上の例では引数が１つしかないが，引数が複数ある場合にその位置が重要になってくる。次の例を考えよう。"
+    "## オブジェクトとメソッド"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "def func_1(a, b):\n",
-    "    return a/b"
+    "### オブジェクト"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [],
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
-    "func_1(10, 2)"
+    "`Python`を習うと「オブジェクト」という単語が必ず出てくる。今の内にイメージをつかむために自転車をオブジェクトの例として考えてみよう。通常の自転車には車輪が２つあり，サドルが１つあり，左右にペダルが２つある。これらの数字が自転車に関する**データ**である。またペダルを踏むことにより前に動き，ハンドルを右にきると右方向に進むことになる。即ち，あることを実行すると，ある結果が返されるのである。これは数学の**関数**と同じように理解できる。$y=x^2$の場合，$x$が`2`であれば$y$の値として`4`が返される。このように自転車はデータと関数が備わっているオブジェクトとして考えることができる。また，車輪の数やペダルを踏むことは自転車特有のデータと関数であり，他のオブジェクト（例えば，冷蔵庫）にはない。即ち，世の中の「オブジェクト」にはそれぞれ異なるデータと関数が存在していると考えることができる。\n",
+    "\n",
+    "`Python`の世界でも「すべて」をこれと同じように考え，データを**属性**と呼び，関数を**メソッド**と呼ぶ。整数型`10`を例にあげると，単なる数字に見えるが，実は様々な属性とメソッドから構成されるオブジェクトなのである。\n",
+    "1. **属性**（attributes）は`10`が持つ様々なデータ（例えば，`10`という値や整数型という情報）\n",
+    "1. **メソッド**（methods）は`10`特有の関数（例えば，加算，除算のように`10`というデータに働きかける関数）\n",
+    "\n",
+    "自転車と冷蔵庫は異なるデータと関数を持つように，整数型`10`と文字列型`神戸大学`は異なるデータと関数を備えるオブジェクトなのである。この考え方は`Python`のすべてに当てはまる。即ち，Everything is an object in Python.\n",
+    "\n",
+    "（メソッドも属性の一種と考えることもできるが，以下では上の分け方に沿って`Python`の使い方を説明する。）"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "`a`が第1引数、`b`が第2引数である。引数の順番を間違えると意図しない結果につながる。"
+    "### メソッド"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "func_1(2, 10)"
+    "例えば，上で定義した`division()`や組み込み関数`sum()`は関数であり，特定のオブジェクトに働きかけるものではない。単に引数から計算した返り値を出力しており，計算できる引数である限りどのようなオブジェクトでも構わない。一方，メソッドは元々オブジェクトに備わっている関数である。例として，文字列`I love 神戸!`を考えよう。`I love 神戸!`というオブジェクトには様々なメソッドが用意されており，そのリストを`dir()`という組み込み関数を使うことにより表示できる。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
-    "hidden": true
+    "hidden": true,
+    "tags": [
+     "output_scroll"
+    ]
    },
+   "outputs": [],
    "source": [
-    "もちろん，3つ以上の位置引数も設定可能である。次の例で使う`sum()`は，数字の合計を計算する関数であり，`()`の中にはタプルやリストが入る。即ち，タプルやリストの要素の合計を返す関数となる。"
+    "moji = 'I love 神戸!'\n",
+    "dir(moji)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "def func_2(a, b, c, d):\n",
-    "    return sum((a, b, c, d))"
+    "アルファベット順に並んでいることが分かる。例として，メソッド`upper`を使ってみる。"
    ]
   },
   {
@@ -2363,17 +2733,16 @@
    },
    "outputs": [],
    "source": [
-    "func_2(10, 20, 30, 40)"
+    "moji.upper()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true,
     "hidden": true
    },
    "source": [
-    "### 実行する際に`=`を使う"
+    "`upper`はアルファベットを大文字に変換するメソッドであり，`moji`にもともと備わっている関数である。"
    ]
   },
   {
@@ -2382,18 +2751,20 @@
     "hidden": true
    },
    "source": [
-    "**関数を実行する際**に、引数に`=`を使って値を指定することも可能である。"
+    "```{note}\n",
+    "* `moji`の後に`.upper()`が来ており`()`に引数がないように見えるが，実は先にある`moji`を引数として`upper()`を実行しているのである。\n",
+    "* `upper`はメソッドの名前であって，実行するには`()`が必要となる。つけ忘れるとオブジェクトのデータ型が表示されることになる。これは関数と同じである。\n",
+    "\n",
+    "```"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "func_1(a=10, b=2)"
+    "`_`はアンダースコア（underscore）と呼ぶが，２つ連続した場合`__`となりダブル・アンダースコア（double underscore）と呼ぶ。長いのでダンダー（dunder）と省略する場合が多々ある。上のリストにはこのダンダーに挟まれたメソッドが含まれている（ダンダー・メソッドと呼ばれる）。これらは対応するコードを実行するとPythonが裏で使うメソッドであるため，直接コードに書く必要はない。"
    ]
   },
   {
@@ -2402,7 +2773,7 @@
     "hidden": true
    },
    "source": [
-    "この場合，引数の順番を変えることが可能となる。それが関数を実行する際に`=`を使う利点である。"
+    "「全てがオブジェクト」なのでリストもそうである。"
    ]
   },
   {
@@ -2413,16 +2784,7 @@
    },
    "outputs": [],
    "source": [
-    "func_1(b=2, a=10)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
-   "source": [
-    "この場合，全ての引数に`=`を使わないとエラーとなる。"
+    "lst = [4, 3, 9, 0, 1]"
    ]
   },
   {
@@ -2431,12 +2793,12 @@
    "metadata": {
     "hidden": true,
     "tags": [
-     "raises-exception"
+     "output_scroll"
     ]
    },
    "outputs": [],
    "source": [
-    "func_1(10,a=2)"
+    "dir(lst)"
    ]
   },
   {
@@ -2445,7 +2807,7 @@
     "hidden": true
    },
    "source": [
-    "理由は最初の`10`を`a`の値と解釈されるためである。一方で，引数の位置が揃っていれば，全ての引数に`=`を付ける必要はない。"
+    "この中に`append`とあるが，`for`ループの説明で使ったメソッドである。"
    ]
   },
   {
@@ -2456,16 +2818,18 @@
    },
    "outputs": [],
    "source": [
-    "func_2(10, 20, d=40, c=30)"
+    "lst.append(100)"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "ここでも引数の位置が重要な役割を果たしている。"
+    "lst"
    ]
   },
   {
@@ -2474,16 +2838,18 @@
     "hidden": true
    },
    "source": [
-    "### 定義する際に`=`を使う"
+    "他に`sort`とあるがこれは要素を昇順に並び替えるメソッドである。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "**関数を定義する際**、`=`を使って引数のデフォルトの値を設定することができる。即ち，引数を入力すると入力された数値を使うが，引数を入力しない場合は引数を予め設定した値（デフォルトの値）が使われて評価される。次の例では`c`のデフォルトの値が`10`に設定されている。"
+    "lst.sort()"
    ]
   },
   {
@@ -2494,8 +2860,7 @@
    },
    "outputs": [],
    "source": [
-    "def func_3(a, b, c=10):\n",
-    "    return sum([a,b])*c"
+    "lst"
    ]
   },
   {
@@ -2504,59 +2869,50 @@
     "hidden": true
    },
    "source": [
-    "`c`の値を与えずに評価してみる。"
+    "オブジェクトのメソッドを調べる場合，`dir()`の出力は見にくいので，`py4macro`モジュールに含まれる`see()`関数を使うのがおすすめである（モジュールについては次のセクションを参照）。もちろん，Pythonやモジュールの説明書（docs）をチェックするのも必要である。"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "func_3(2, 3)"
+    "## `if` 文"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "次に`c`にデフォルトと異なる値を設定してみる。"
+    "`if`文を説明する前に`print()`関数について触れておく。`Python`を起動すると，多くの関数が使える状態になる。その一つが`print()`関数であり，値を表示することができる。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "func_3(2, 3, 100)"
+    "pi = 3.14\n",
+    "print(pi)"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "（Note）\n",
-    "* 関数を実行する際に`=`無しで関数に渡される引数は，その位置が重要であるため「位置引数」と呼ばれる。\n",
-    "* 関数を実行する際に`=`付きで関数に渡される引数は「キーワード引数」と呼ばれる。"
+    "コンマ`,`を使うと複数の値を表示することができる。"
    ]
   },
   {
-   "cell_type": "markdown",
-   "metadata": {
-    "heading_collapsed": true,
-    "hidden": true
-   },
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "### `*args`"
+    "print(pi, 'は円周率です。')"
    ]
   },
   {
@@ -2565,19 +2921,11 @@
     "hidden": true
    },
    "source": [
-    "`func_0()`の引数の数は1に，`func_1()`の引数は2に，`func_2()`の引数は4に設定されている。関数を実行する際，引数の数が指定された数と合わないとエラーが発生する。では，位置引数の数が事前に決まっていない場合はどうするのか。例えば，`func_2(1,2)`と書いても`func_2(1,2,3,4,5,6)`と書いても引数の合計を計算したいとしよう。このような場合に`*args`を使う。"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [],
-   "source": [
-    "def func_4(*args):\n",
-    "    return sum(args)"
+    "`if`文を使うと，あるブール型（真偽）の条件のもとでコードを実行することが可能となる。例えば，`x`の値が正の場合，\n",
+    "\n",
+    "`print(x, 'は正です')`\n",
+    "\n",
+    "を実行したいとしよう。"
    ]
   },
   {
@@ -2588,7 +2936,7 @@
    },
    "outputs": [],
    "source": [
-    "func_4(1,2)"
+    "x = 10"
    ]
   },
   {
@@ -2599,7 +2947,11 @@
    },
    "outputs": [],
    "source": [
-    "func_4(1,2,3,4,5,6)"
+    "if x > 0:\n",
+    "    print(x, 'は正です。')\n",
+    "    \n",
+    "else:\n",
+    "    print(x, 'は正ではありません。')"
    ]
   },
   {
@@ -2608,27 +2960,38 @@
     "hidden": true
    },
    "source": [
-    "`*args`は何を返しているのだろうか。実は，`args`はタプルを返し，`*args`はタプルから取り出した全ての要素を返している。これを理解するために次の例を考えよう。"
+    "＜注意点＞\n",
+    ">* `if`と`else` で始まる条件を示す行の最後は`:`となる。\n",
+    ">* `print()`の行は４つの半角スペースのインデントを入れること。（半角スペースが入っていれば，スペースの数は関係なしにエラーは発生しない。しかし可読性向上のために４つの半角スペースを使うことが慣例となっている。）\n",
+    ">* `else`とは「`X>0`以外の場合」という意味。\n",
+    "\n",
+    "ここで`else`以下を省略してもエラーにはならないが，`x>0`が`False`の場合，なにも表示されない。"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "print((1,2,3))"
+    "次に，複数の条件を導入するために次の３つ`print`関数を使おう。\n",
+    "\n",
+    "1. `print(X, 'は正です')`\n",
+    "1. `print(X, 'はゼロです')`\n",
+    "1. `print(X, 'は負です')`\n",
+    "\n",
+    "`X`の値が正の場合は`1`を，ゼロの場合は`2`を，負の場合は`3`を表示したいとしよう。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "ここではタプル`(1,2,3)`を表示している。次に、`*`を加えてみる。"
+    "x = -1"
    ]
   },
   {
@@ -2639,7 +3002,14 @@
    },
    "outputs": [],
    "source": [
-    "print(*(1,2,3))"
+    "if x == 0:\n",
+    "    print(x, 'はゼロです。')\n",
+    "    \n",
+    "elif x > 0:\n",
+    "    print(x, 'は正です。')\n",
+    "    \n",
+    "else:\n",
+    "    print(x, 'は負です。')"
    ]
   },
   {
@@ -2648,18 +3018,22 @@
     "hidden": true
    },
    "source": [
-    "これは次のコードの返り値と同じである。"
+    "注意点\n",
+    "* `if`, `elif`, `else` で始まる条件を示す行の最後は`:`となる。\n",
+    "* `print()`の行は４つの半角スペースのインデントが入る。\n",
+    "* `elif`は`else if`の省略形であり，２つ目の条件を定義する。\n",
+    "* `elif`は`if`と`else`の間に複数入れることが可能\n",
+    "* `x<0`の条件は不要（残りの可能性は`x<0`しかないため）"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "print(1,2,3)"
+    "## `for`ループ"
    ]
   },
   {
@@ -2668,7 +3042,7 @@
     "hidden": true
    },
    "source": [
-    "即ち、`*`はタプル`(1,2,3)`の全ての要素を取り出して`1,2,3`に置き換えている。このような置き換えを「展開する」（unpack）と呼ぶ。この`*`の役割を念頭に次の関数を使い`*`と`args`の役割を分けて考えてみる。"
+    "`for`ループは同じコードを複数回リピートして実行したい場合に有効な方法である。例えば，次のリストにある名前を表示したいとしよう。"
    ]
   },
   {
@@ -2679,19 +3053,7 @@
    },
    "outputs": [],
    "source": [
-    "def func_5(*args):\n",
-    "    print(args)\n",
-    "\n",
-    "func_5(1,2,3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
-   "source": [
-    "`args`自体は引数のタプルであることがわかる。次に`print()`の`args`に`*`を加える。"
+    "name_lst = ['太郎', '次郎', '三郎', '四郎', '五郎']"
    ]
   },
   {
@@ -2702,10 +3064,9 @@
    },
    "outputs": [],
    "source": [
-    "def func_5(*args):\n",
-    "    print(*args)\n",
-    "\n",
-    "func_5(1,2,3)"
+    "for name in name_lst:\n",
+    "    \n",
+    "    print(name)"
    ]
   },
   {
@@ -2714,25 +3075,15 @@
     "hidden": true
    },
    "source": [
-    "ここから分かることは、`func_5(*args)`の`args`自体はタプルであり，`*args`はタプルを展開したものである。`print(*args)`の`*args`もタプルを展開したものである。このことを念頭にもう一度`func_4(*args)`を考えてみよう。`def func_4(*args)の`の`args`は引数になる数字のタプル（例えば，`(1,2,3)`）であり，`*args`はそれを展開したものである。`return sum(args)`の`args`はもちろんタプルである。この性質を使うことにより、関数に任意の数の引数を指定することが可能となる。\n",
+    "説明と注意点\n",
+    "* `for`がある一行目は`:`で終わる。\n",
+    "* `name`は`name_lst`にあるそれぞれの要素を割り当てる変数。`name`ではなく`i`や`s`など使いやすい記号を使って構わない。\n",
+    "* `name_lst`にある要素を最初から一つずつ実行する。\n",
+    "* 2行目は4つの半角スペースを使ってインデントしている。\n",
     "\n",
-    "＜コメント＞\n",
-    "* `*args`の`args`はarguments（引数）の省略形である。\n",
-    "* `*args`の代わりに`*aaa`や`*abc`としても同じ結果をえることができる。しかし`*args`と書くのが慣例である。\n",
+    "`for`ループでよく使うパターンして次の例を考える。この例では，リストに要素を追加する`.append()`を使うが，これについては以下でより詳しく説明する。\n",
     "\n",
-    "次の例は`*args`と引数を一緒に使うケースである。"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [],
-   "source": [
-    "def func_6(a, *args):\n",
-    "    return a*sum(args)"
+    "まず次のリストを定義する。"
    ]
   },
   {
@@ -2743,7 +3094,7 @@
    },
    "outputs": [],
    "source": [
-    "func_6(10,2,2,2)"
+    "var_lst = [10, 20, 30, 40, 50]"
    ]
   },
   {
@@ -2752,19 +3103,22 @@
     "hidden": true
    },
    "source": [
-    "＜注意＞\n",
-    "\n",
-    "必ず`*args`は位置引数の後に置くこと。これは`*args`が「その他全ての位置引数」という意味であるためであり、全ての位置引数の後に位置してこそ意味があるからである。言い換えると、`*args`は位置引数の終わりを意味する。"
+    "それぞれの要素の2倍からなるリストを作成したいとしよう。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
-    "heading_collapsed": true,
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "### `lambda`関数"
+    "my_lst = []  # 1\n",
+    "\n",
+    "for i in var_lst:  # 2\n",
+    "    \n",
+    "    my_lst.append(2*i)  # 3"
    ]
   },
   {
@@ -2773,7 +3127,13 @@
     "hidden": true
    },
    "source": [
-    "上の例では`def`を使う方法を紹介したが，複雑な関数を定義する場合によく使われる。一方で単純な関数の場合，より簡単な方法がある。それが`lambda`関数である。例として，$x^2$を計算する関数を考えよう。"
+    "このループの考え方：\n",
+    "\n",
+    "1. 空のリストの作成（ここに2倍にした数字を格納する）\n",
+    "1. ここから`for`ループの始まりとなる。`i`はループを回していく際に`[10,20,30,40,50]`の各要素を割り当てる変数となる。`var_lst`には５つの要素があるので５回同じ作業を繰り返す。１回目のループでは，`var_lst`の`0`番目の要素`10`を`i`に割り当てる。次の行に進んで，その行の評価が終わると２回目のループが始まり，`var_lst`の`1`番目の要素`20`を`i`に割り当てる。そして次の行に進み，その評価が終わると`３`回目のループが始まり，同じ作業が続く。ループは５回目で終わることになる。\n",
+    "1. `.append()`は`2*i`を`my_lst`に追加するリストのメソッド（関数と同義であり，後ほど違いを説明する）であり，この行が評価される毎に`my_lst`に`2*i`が追加されて行くことになる。\n",
+    "\n",
+    "このように，`for`ループとは上のコードの２〜３を５回繰り返している。`my_lst`を表示しよう。"
    ]
   },
   {
@@ -2784,9 +3144,7 @@
    },
    "outputs": [],
    "source": [
-    "func_7 = lambda a: a**2\n",
-    "\n",
-    "func_7(2)"
+    "print(my_lst)"
    ]
   },
   {
@@ -2795,18 +3153,18 @@
     "hidden": true
    },
    "source": [
-    "複数の引数の場合"
+    "```{note}\n",
+    "上の例では`for`ループの１行目に**リスト**を使って（`name_lst`や`var_lst`），`0`番目の要素から順に関数・メソッドを使った。これはリストが要素を１つずつ返すことができる反復可能なものであり，**iterable`と呼ばれ，タプルや文字列，そして後で説明する`Numpy`の`array`も含まれる。\n",
+    "```"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "func_8 = lambda a, b: a*b"
+    "次の例では文字列を一文字ずつ表示する。"
    ]
   },
   {
@@ -2817,27 +3175,31 @@
    },
    "outputs": [],
    "source": [
-    "func_8(2,3)"
+    "my_str = 'Kobe'    # 文字列を作成しmy_strに割り当てる\n",
+    "\n",
+    "for s in my_str:   # forループの開始\n",
+    "    \n",
+    "    print(s)       # 文字を表示"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "引数が無い場合"
+    "基本的な考え方：\n",
+    "1. `1`回目のループで`K`が`s`に割り当てられ，`K`が表示される。\n",
+    "2. `2`回目のループで`o`が`s`に割り当てられ，`o`が表示される。\n",
+    "3. `3`回目のループで`b`が`s`に割り当てられ，`b`が表示される。\n",
+    "4. `4`回目のループで`e`が`s`に割り当てられ，`e`が表示される。"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "func_9 = lambda : 'I love Kobe ;)'"
+    "`for`ループの中に`if`を使う例を考えてみよう。偶数を10倍にし，奇数を1/10にしている。"
    ]
   },
   {
@@ -2848,104 +3210,134 @@
    },
    "outputs": [],
    "source": [
-    "func_9()"
+    "my_lst = []           # 空のリストの作成\n",
+    "\n",
+    "for i in var_lst:     # forループの開始\n",
+    "    \n",
+    "    if i % 2 ==0:     # 余りが０の場合\n",
+    "        x = 10*i      # 10倍にしてxに割り当てる\n",
+    "        \n",
+    "    else:             # 余りが０でない場合\n",
+    "        x = i/10      # 10分の１にしてxに割り当てる\n",
+    "        \n",
+    "    my_lst.append(x)  # xをmy_lstに追加\n",
+    "        \n",
+    "print(my_lst)         # my_lstの表示"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "## 関数とメソッド"
+    "## 内包表記"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "Pythonには「関数（functions）」と「メソッド（methods）」があり，基本的には同じ働きをする。ではどう異なるのか。これを理解するためには，数字の`1`を含めて「全てがオブジェクト」というPythonの根底にある考え方を思い出そう。簡単に説明すると，オブジェクトにもともと備わっているかどうかで「関数」と「メソッド」に区別されると思って十分である。\n",
+    "リストの内包表記（list comprehension）とはforループの考えを使い、リストを簡単に１行で生成する方法である。次の構文となる。\n",
+    "```\n",
+    "[＜実行したい内容＞ for ＜要素を割り当てる変数＞ in ＜イタラブル＞]\n",
+    "```\n",
+    "* `for ＜要素を割り当てる変数＞ in ＜イタラブル＞`はforループの１行目と同じとなる。\n",
+    "* ＜イタラブル＞はリストやタプルなどを指す。\n",
+    "* ＜要素を割り当てる変数＞には`i`や`_`などを使う。\n",
+    "* `:`は入らない。\n",
+    "* ＜実行したい内容＞の箇所でループで実行したいコードを書く。\n",
     "\n",
-    "例えば、上で定義した`func_0()`や`func_7()`は関数であり，特定のオブジェクトに働きかけるものではない。単に引数から計算した返り値を出力しており，計算できる引数である限りどのようなオブジェクトでも構わない。一方，メソッドは元々オブジェクトに備わっている関数である。例として，文字列`I love 神戸!`を考えよう。`I love 神戸!`というオブジェクトには様々なメソッドが用意されており，そのリストを`dir()`という関数を使うことにより表示できる。"
+    "`for`ループと比べて例を考える方が分かりやすいだろう。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true,
-    "tags": [
-     "output_scroll"
-    ]
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "moji = 'I love 神戸!'\n",
-    "dir(moji)"
+    "lst = []\n",
+    "\n",
+    "for i in range(5):\n",
+    "    \n",
+    "    lst.append(i**2)\n",
+    "\n",
+    "lst"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "アルファベット順に並んでいることが分かる。例として，`upper`を使ってみる。"
+    "このコードは`0`から`4`までの整数を2乗したリストを作成している。内包表記を使うと１行で書ける。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "moji.upper()"
+    "lst_lc = [i**2 for i in range(5)]\n",
+    "\n",
+    "lst_lc"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "`upper`はアルファベットを大文字に変換するメソッドであり，`moji`にもともと備わっている関数である。"
+    "forループと内包表記を並べると２つの関係がより分かりやすくなるだろう。"
    ]
   },
   {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "```{note}\n",
-    "* `moji`の後に`.upper()`が来ており`()`に引数がないように見えるが，実は先にある`moji`を引数として`upper()`を実行しているのである。\n",
-    "* `upper`はメソッドの名前であって，実行するには`()`が必要となる。つけ忘れるとオブジェクトの型が表示されることになる。これは関数と同じである。\n",
+    "lst = []\n",
+    "for i in range(5):      #1\n",
+    "    lst.append(i**2)\n",
     "\n",
-    "```"
+    "[\n",
+    "    i**2\n",
+    "    for i in range(5)   #2\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`#1`と`#2`は殆ど同じになっており、違いは`:`だけとなる。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "`_`はアンダースコア（underscore）と呼ぶが，２つ連続した場合`__`となりダブル・アンダースコア（double underscore）と呼ぶ。長いのでダンダー（dunder）と省略する場合が多々ある。上のリストにはこのダンダーに挟まれたメソッドが含まれている（ダンダー・メソッドと呼ばれる）。これらは対応するコードを実行するとPythonが裏で使うメソッドであるため，直接コードに書く必要はない。例えば，次のコードを考えてみよう。"
+    "## パッケージとモジュール"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "moji + ' (^o^)/'"
+    "Pythonには組み込み関数が多く用意されている。例えば，[このリンク](https://docs.python.org/ja/3/library/functions.html)を参照。しかし組み込み関数には計量経済学用の便利な関数は用意されていない。そこで活躍するのがモジュール（modules）やパッケージ（package）と呼ばれるものである。もちろん計量経済学以外のモジュールやパッケージが無数にあり，使う用途（例えば，グラフを描く）に沿って読み込むことになる。２つの違いを簡単にいうと\n",
+    "\n",
+    "* モジュールは１つのファイル（.py）にまとめられた関数群であり，\n",
+    "* パッケージは複数つのファイル（.py）で構成され，フォルダーにまとめられているもの\n",
+    "\n",
+    "となる。従って，モジュール全体を読み込んだり，あるパッケージの１つのモジュールだけを読み込むということも可能である。\n",
+    "\n",
+    "まず例として`random`モジュールを考える。ランダム変数を生成する関数が含まれるモジュールである。使うためには`import`を使って読み込む必要がある。"
    ]
   },
   {
@@ -2954,7 +3346,7 @@
     "hidden": true
    },
    "source": [
-    "`+`を使い文字列を結合しているが，この裏でPythonが使っているメソッドが`__add__`である。"
+    "モジュールの全てを読み込むとモジュール内の全ての関数が使用可能となる。"
    ]
   },
   {
@@ -2965,7 +3357,7 @@
    },
    "outputs": [],
    "source": [
-    "moji.__add__(' (^o^)/')"
+    "import random"
    ]
   },
   {
@@ -2974,32 +3366,32 @@
     "hidden": true
    },
    "source": [
-    "`+`は`__add__`の便利な省略形を考えれば良いだろう。「全てがオブジェクト」なのでリストもそうである。"
+    "```{hint}\n",
+    "通常，モジュールやパッケージをインポートする上のようなコードは，ファイルの一番上に書くのが慣例となっているので，それに従うことにしよう。\n",
+    "```"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [],
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
-    "list_0 = [4,3,9,0,1]"
+    "様々な関数が用意されているが，その中の`randint()`関数は、引数で指定するランダムな整数を返す。\n",
+    "\n",
+    "* 第１引数：最小値（整数型）\n",
+    "* 第２引数：最大値（整数型）\n",
+    "\n",
+    "次のコードは$[0,6]$の間の整数（サイコロの目）を返す。`1`と`6`は戻り値に含まれることに注意しよう。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "hidden": true,
-    "tags": [
-     "output_scroll"
-    ]
+    "hidden": true
    },
    "outputs": [],
    "source": [
-    "dir(list_0)"
+    "random.randint(1, 6)    # randint　は random integers (ランダムな整数)の略"
    ]
   },
   {
@@ -3008,38 +3400,30 @@
     "hidden": true
    },
    "source": [
-    "この中に`append`とあるが，`for`ループの説明で使ったメソッドである。"
+    "このコードの「`.`」を助詞「の」と読んで，`random.randint`の部分を「`random`モジュールの`randint`関数」と読むことができる。このコードの先頭に`random`があるのは、他のパッケージやモジュールに`.randint()`関数がある場合、それとバッティングしないようにするためである。"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
-   "outputs": [],
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
-    "list_0.append(100)"
+    "内包表記を使って、`10`回サイコロを投げた結果をリストで表示してみよう。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "list_0"
+    "[random.randint(1, 6) for _ in range(10)]"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "他に`sort`とあるがこれは要素を昇順に並び替えるメソッドである。"
+    "モジュール名が長い場合は，短い名前で読み込むことも可能である。"
    ]
   },
   {
@@ -3050,7 +3434,14 @@
    },
    "outputs": [],
    "source": [
-    "list_0.sort()"
+    "import random as rm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "「`random`モジュールを`rm`としてを読み込む」と理解すれば良いだろう。"
    ]
   },
   {
@@ -3061,7 +3452,7 @@
    },
    "outputs": [],
    "source": [
-    "list_0"
+    "rm.randint(1, 6)"
    ]
   },
   {
@@ -3070,16 +3461,18 @@
     "hidden": true
    },
    "source": [
-    "是非他のメソッドも試して欲しい。またオブジェクトのメソッドを調べる場合，`dir()`の出力は見にくいので，`py4macro`モジュールに含まれる`see()`関数を使うのがおすすめである（モジュールについては次のセクションを参照）。もちろん，Pythonやモジュールの説明書（docs）をチェックするのも必要である。"
+    "モジュール内の特定の関数だけを読み込むことも可能である。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
-    "heading_collapsed": true
+    "hidden": true
    },
+   "outputs": [],
    "source": [
-    "## パッケージとモジュール"
+    "from random import randint"
    ]
   },
   {
@@ -3088,34 +3481,27 @@
     "hidden": true
    },
    "source": [
-    "Pythonには組み込み関数が多く用意されている。例えば，[このリンク](https://docs.python.org/ja/3/library/functions.html)を参照。しかし組み込み関数には計量経済学用の便利な関数は用意されていない。そこで活躍するのがモジュール（modules）やパッケージ（package）と呼ばれるもである。もちろん計量経済学以外のモジュールやパッケージが無数にあり，使う用途（例えば，グラフを描く）に沿って読み込むことになる。２つの違いを簡単にいうと\n",
-    "\n",
-    "* モジュールは１つのファイル（.py）にまとめられた関数群であり，\n",
-    "* パッケージは複数つのファイル（.py）で構成され，フォルダーにまとめられているもの\n",
-    "\n",
-    "となる。従って，モジュール全体を読み込んだり，あるパッケージの１つのモジュールだけを読み込むということも可能である。\n",
-    "\n",
-    "まず例として`math`モジュールを考える。名前が示すように数学用のモジュールである。使うためには`import`を使って読み込む必要がある。"
+    "「`random`モジュールから`randint`を読み込む」と理解できる。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "モジュールの全てを読み込むとモジュール内の全ての関数が使用可能となる。"
+    "randint(1, 6)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "import math"
+    "この読み込み方法の利点はモジュール名を省略できることだが、他のパッケージやモジュールと同じ関数がある場合，後で`import`したものが優先され、意図しない結果になり得るので、**この読み込み方法は避けた方が良いだろう**。"
    ]
   },
   {
@@ -3124,11 +3510,7 @@
     "hidden": true
    },
    "source": [
-    "上のコードを実行すると，`math`モジュールに含まれる全ての関数などを読み込むことになる。\n",
-    "\n",
-    "```{hint}\n",
-    "通常，モジュールやパッケージをインポートする上のようなコードは，ファイルの一番上に書くのが慣例となっているので，それに従うことにしよう！\n",
-    "```"
+    "前のセクションで`dir()`を使いオブジェクトの属性を調べたが，`py4macro`モジュールの`see()`関数を使うと属性・メソッドのリストが見やすく。それを使ってみよう。まず，モジュールをインポートする。"
    ]
   },
   {
@@ -3139,7 +3521,7 @@
    },
    "outputs": [],
    "source": [
-    "math.sqrt(4)    # sqrt（）とはルート"
+    "import py4macro"
    ]
   },
   {
@@ -3148,20 +3530,16 @@
     "hidden": true
    },
    "source": [
-    "この場合モジュール名が必要となり，「`math`モジュールの`sqrt`」を指定しているという意味である。これは他のモジュールとバッティングしないようにするためである。\n",
-    "\n",
-    "モジュール名が長い場合は，短い名前で読み込むことも可能である。"
+    "`see()`関数を使ってみよう。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "import math as m"
+    "moji = '神戸大学、良いとこ、一度はおいで🎵'"
    ]
   },
   {
@@ -3172,27 +3550,16 @@
    },
    "outputs": [],
    "source": [
-    "m.sqrt(9)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
-   "source": [
-    "モジュール内の特定の関数だけを読み込むことも可能である。"
+    "py4macro.see(moji)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+  {
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "from math import sqrt, log   # logは自然対数で, sqrtの両方を読み込む"
+    "`py4macro.see`は「`py4macro`モジュールの`see`関数」と読むことができる。`see()`関数を使うと，ダンダー・メソッドは省略され，見やすくなっている。"
    ]
   },
   {
@@ -3201,18 +3568,22 @@
     "hidden": true
    },
    "source": [
-    "「`math`モジュールから`sqrt`と`log`を読み込む」と理解すれば良いだろう。"
+    "````{note}\n",
+    "`py4macro`モジュールはAnacondaに含まれていないので，TerminalもしくはGit Bashで以下を実行して事前にインストールする必要がある。\n",
+    "```\n",
+    "$ pip install py4macro\n",
+    "```\n",
+    "````"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
-   "outputs": [],
    "source": [
-    "sqrt(10)"
+    "## エラー"
    ]
   },
   {
@@ -3221,29 +3592,37 @@
     "hidden": true
    },
    "source": [
-    "この読み込み方法の利点はモジュール名を省略できることである。しかし他のパッケージやモジュールと同じ関数がある場合は，後で`import`したものが優先されるので注意が必要だ。\n",
+    "エラー（Errors）は以下の２つに分けられる。\n",
+    "1. 構文エラー（Syntax Errors）\n",
+    "    * 構文自体が間違っている場合に発生するエラー（例えば，スペル間違い）。\n",
+    "1. 例外（Exceptoins）\n",
+    "    * 構文は間違っていなくてもコードの実行中に発生するエラー（例えば，数字を`0`で割る）\n",
     "\n",
-    "`import`文はファイルの最初に書き，どのモジュールが導入されるかを明示的に示すとわかりやすいだろう。"
+    "---\n",
+    "＜＜コメント＞＞\n",
+    "* エラーが発生するとエラー・メッセージが表示されるが，多くの場合，エラー・メッセージにエラーの理由のヒントがあるので確認することを強く推奨する。はじめは意味が分からないかも知れないが，パターンがあるので慣れると直ぐに理解できるケースも多くあるだろう。\n",
+    "* 例外の場合，最初にエラーが発生するとそれに付随して他の場所でもエラーが誘発される場合がある。`Python`はエラーを追跡し，最後に確認したエラーをメッセージの一番最後に表示する。最初は、一番最後のエラー・メッセージを確認しよう！"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "hidden": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "前のセクションで`dir()`を使いオブジェクトの属性を調べたが，その際`py4macro`モジュールの`see()`関数を使うとリストが見やすくなると説明した。それを使ってみよう。まず，モジュールをインポートする。"
+    "\n",
+    "### 構文エラー"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
+    "heading_collapsed": true,
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "import py4macro"
+    "#### 例１"
    ]
   },
   {
@@ -3252,18 +3631,22 @@
     "hidden": true
    },
    "source": [
-    "使ってみよう。"
+    "（正）`print`<br>\n",
+    "（誤）`primt`"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "hidden": true
+    "hidden": true,
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": [
-    "py4macro.see(moji)"
+    "primt('hello')"
    ]
   },
   {
@@ -3272,7 +3655,9 @@
     "hidden": true
    },
    "source": [
-    "このコードは，「`.`」を「の」と読んで，「`py4macro`の`see()`関数」と読むことができる。`see()`関数を使うと，ダンダー・メソッドは省略され，メソッドには`()`が追加され見やすくなっている。"
+    "* 矢印（---->）でエラー箇所が示されている。\n",
+    "* `NameError`として最終行にスペル間違いである`primt`が示されている。\n",
+    "* `name 'primt' is not defined`とは「`primt`という名前（変数のこと）は上で定義されていない」という意味。"
    ]
   },
   {
@@ -3281,77 +3666,78 @@
     "hidden": true
    },
    "source": [
-    "````{note}\n",
-    "`py4macro`モジュールはAnacondaに含まれていないので，TerminalもしくはGit Bashで以下を実行して事前にインストールする必要がある。\n",
-    "```\n",
-    "$ pip install py4macro\n",
-    "```\n",
-    "````"
+    "#### 例２"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true
+    "hidden": true
    },
    "source": [
-    "## よく使う組み込み関数"
+    "`for`ループの最初の行の終わりに`:`が抜けている。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "hidden": true
+    "hidden": true,
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": [
-    "# 表示\n",
-    "print('私は神戸大学の学生です。')"
+    "a = 3\n",
+    "\n",
+    "for i in range(0,3)\n",
+    "\n",
+    "    print(i)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "# 様々なものからリストを返す関数\n",
-    "list()  # 空のリスト"
+    "* `line 3`はセル内の３行目を示している。\n",
+    "* `SyntaxError`として最後の行で`:`が足りない箇所を`^`で指し示している。\n",
+    "* `expected ':'`とは「`:`があるはず」という意味。"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
+    "heading_collapsed": true,
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "# 0から9までの整数を用意する関数 \n",
-    "range(10)"
+    "#### 例３"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "list(range(0,10))"
+    "最後の括弧を閉じていない。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
-    "heading_collapsed": true
+    "hidden": true,
+    "tags": [
+     "raises-exception"
+    ]
    },
+   "outputs": [],
    "source": [
-    "## エラー"
+    "(2.1 + 1.5) / (10.0 + 1.0 + 3.2 "
    ]
   },
   {
@@ -3360,33 +3746,27 @@
     "hidden": true
    },
    "source": [
-    "エラー（Errors）は以下の２つに分けられる。\n",
-    "1. 構文エラー（Syntax Errors）\n",
-    "    * 構文自体が間違っている場合に発生するエラー（例えば，スペル間違い）。\n",
-    "1. 例外（Exceptoins）\n",
-    "    * 構文は間違っていなくてもコードの実行中に発生するエラー（例えば，数字を`0`で割る）\n",
-    "\n",
-    "---\n",
-    "＜＜コメント＞＞\n",
-    "* エラーが発生するとエラー・メッセージが表示されるが，多くの場合，エラー・メッセージにエラーの理由のヒントがあるので確認することを強く推奨する。はじめは意味が分からないかも知れないが，パターンがあるので慣れると直ぐに理解できるケースも多くあるだろう。\n",
-    "* 例外の場合，最初にエラーが発生するとそれに付随して他の場所でもエラーが誘発される場合がある。`Python`はエラーを追跡し，最後に確認したエラーをメッセージの一番最後に表示するので覚えておこう。"
+    "この場合，`Python`はプログラマーがどこに`)`を入れようとしたかは分からない。従って，最後に`)`が入ると想定して`^`を文末に置いている。\n",
+    "* `incomplete input`とは「不完全なインプット」という意味。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "hidden": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "\n",
-    "### 構文エラー"
+    "### 例外"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "heading_collapsed": true,
-    "hidden": true
+    "hidden": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
     "#### 例１"
@@ -3398,8 +3778,7 @@
     "hidden": true
    },
    "source": [
-    "（正）`print`<br>\n",
-    "（誤）`primt`"
+    "`0`が分母にある。"
    ]
   },
   {
@@ -3413,23 +3792,22 @@
    },
    "outputs": [],
    "source": [
-    "primt('hello')"
+    "2.0 + 1/0"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "* 矢印（---->）でエラー箇所が示されている。\n",
-    "* `NameError`として最終行にスペル間違いである`primt`が示されている。"
+    "* `division by zero`とは「`0`で除している」という意味。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "hidden": true
+    "heading_collapsed": true,
+    "hidden": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
     "#### 例２"
@@ -3441,7 +3819,7 @@
     "hidden": true
    },
    "source": [
-    "次のセルの３行目の終わりに`:`が抜けている。"
+    "定義されていない変数`xx`が使われている。"
    ]
   },
   {
@@ -3455,27 +3833,22 @@
    },
    "outputs": [],
    "source": [
-    "a = 3\n",
-    "\n",
-    "for i in range(0,3)\n",
-    "    print(i)"
+    "10 + xx * 2"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "* `line 3`はセル内の３行目を示している。\n",
-    "* `SyntaxError`として最後の行で`:`が足りない箇所を`^`で指し示している。"
+    "* `name 'xx' is not defined`とは「`xx`という名前（変数）は上で定義されていない」という意味。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "heading_collapsed": true,
-    "hidden": true
+    "hidden": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
     "#### 例３"
@@ -3487,7 +3860,7 @@
     "hidden": true
    },
    "source": [
-    "括弧を閉じていない。"
+    "文字列とfloatを足している。"
    ]
   },
   {
@@ -3501,7 +3874,24 @@
    },
    "outputs": [],
    "source": [
-    "(2.1 + 1.5)/(10.0 + 1.0 + 3.2 "
+    "'3' + 10"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* `can only concatenate str (not \"int\") to str`とは「文字列型と文字列型のみを連結することができる（文字列型と整数型は不可）」という意味。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "heading_collapsed": true,
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "## ヘルプ"
    ]
   },
   {
@@ -3510,11 +3900,7 @@
     "hidden": true
    },
    "source": [
-    "この場合，`Python`はプログラマーがどこに`)`を入れようとしたかは分からない。従って，最後に`)`が入ると想定して`^`を文末に置いている。\n",
-    "\n",
-    "---\n",
-    "＜＜コメント１＞＞<br>\n",
-    "`()`の場合，改行しても構わない。一行が長くなる場合，`(`と`)`の間で改行することができる。"
+    "組み込み関数である`help()`を使うと関数やモジュールなどの`Docstring`と呼ばれる説明を表示させることができる。例えば，`print()`を例として挙げる。"
    ]
   },
   {
@@ -3525,8 +3911,7 @@
    },
    "outputs": [],
    "source": [
-    "(10, 20, 30,\n",
-    " 40, 50, 50)"
+    "help(print)"
    ]
   },
   {
@@ -3535,8 +3920,19 @@
     "hidden": true
    },
    "source": [
-    "＜＜コメント２＞＞<br>\n",
-    "文字列を改行する場合は次の例のように`\\`を使う。"
+    "**＜注意＞**<br>\n",
+    "`help()`関数の引数は関数名であり`()`は付いていない。`()`を付けると`print()`を評価した結果に対しての説明が表示されることになる。\n",
+    "\n",
+    "英語の説明しかないが、パターンを理解すればこれだけでも有用に感じることだろう。 "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "hidden": true
+   },
+   "source": [
+    "`help()`の代わりに`?`を使うこともできる。"
    ]
   },
   {
@@ -3547,61 +3943,53 @@
    },
    "outputs": [],
    "source": [
-    "'神戸大学\\\n",
-    "経済学部'"
+    "print?"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true,
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "### 例外"
+    "## ヒントと注意点"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true,
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "#### 例１"
+    "### ヒント１"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "hidden": true
-   },
+   "metadata": {},
    "source": [
-    "`0`が分母にある。"
+    "`()`の場合，改行しても構わない。一行が長くなる場合，`(`と`)`の間で改行することができる。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "hidden": true,
-    "tags": [
-     "raises-exception"
-    ]
+    "hidden": true
    },
    "outputs": [],
    "source": [
-    "2.0 + 1/0"
+    "(10, 20, 30,\n",
+    " 40, 50, 50)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true,
-    "hidden": true
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "#### 例２"
+    "### ヒント２"
    ]
   },
   {
@@ -3610,31 +3998,29 @@
     "hidden": true
    },
    "source": [
-    "定義されていない変数`xx`が使われている。"
+    "文字列を改行する場合は次の例のように`\\`を使う。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "hidden": true,
-    "tags": [
-     "raises-exception"
-    ]
+    "hidden": true
    },
    "outputs": [],
    "source": [
-    "10 + xx * 2"
+    "'神戸大学\\\n",
+    "経済学部'"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true,
-    "hidden": true
+    "hidden": true,
+    "jp-MarkdownHeadingCollapsed": true
    },
    "source": [
-    "#### 例３"
+    "### 注意点：スコープ"
    ]
   },
   {
@@ -3643,59 +4029,84 @@
     "hidden": true
    },
    "source": [
-    "文字列とfloatを足している。"
+    "スコープとは、変数が所属し直接アクセスできるコードの中の「領域」を示す。類似する概念に名前空（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,
-    "tags": [
-     "raises-exception"
-    ]
+    "hidden": true
    },
    "outputs": [],
    "source": [
-    "'3' + 10"
+    "s = \"Kobe Univ\"   # globalスコープ\n",
+    "\n",
+    "def scope_0():\n",
+    "    s = \"神戸大学\"  # localスコープ\n",
+    "    return s\n",
+    "\n",
+    "scope_0()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true
+    "hidden": true
    },
    "source": [
-    "## ヘルプ"
+    "この関数を実行すると、Pythonはまず関数`scope_0`のローカル・スコープ内で変数`s`を探すことになる。ローカル・スコープに`s`があるので、それを返している。次の関数を考えよう。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "組み込み関数`help()`を使うと関数やモジュールなどの`Docstring`と呼ばれる説明を表示させることができる。例えば，`print()`を例として挙げる。"
+    "def scope_1():\n",
+    "    return s\n",
+    "\n",
+    "scope_1()"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {
     "hidden": true
    },
-   "outputs": [],
    "source": [
-    "help(print)"
+    "この例では、まず`Python`はローカル・スコープに`s`があるかを確かめる。ローカル・スコープにないため、次にグローバル・スコープに`s`がないかを確かめている。グローバル・スコープに`s`があったので、それを返している（ないとエラーが出る）。\n",
+    "\n",
+    "次の例では、グローバル・スコープからローカル・スコープの変数へのアクセスを考える。"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {
     "hidden": true
    },
+   "outputs": [],
    "source": [
-    "引数は関数名であり`()`は付いていないことに注意しよう。`()`を付けると`print()`を評価した結果に対しての説明が表示されることになる。英語での説明だがパターンを理解すればこれだけでも有用に感じることだろう。 "
+    "def scope_2():\n",
+    "    s_local = 'Pythonは楽しい(^o^)/'\n",
+    "    return s_local\n",
+    "\n",
+    "scope_2()"
    ]
   },
   {
@@ -3704,23 +4115,28 @@
     "hidden": true
    },
    "source": [
-    "`help()`の代わりに`?`を使うこともできる。"
+    "`s_local`は関数`scope_2`のローカル・スコープで定義されている。グローバル・スコープからアクセスしようとするとエラーが発生する。"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "hidden": true
+    "hidden": true,
+    "tags": [
+     "raises-exception"
+    ]
    },
    "outputs": [],
    "source": [
-    "print?"
+    "s_local"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
    "source": [
     "## Pythonの基本のまとめ（日英対訳）"
    ]
@@ -3733,13 +4149,6 @@
     "\n",
     "[英語](https://learnxinyminutes.com/docs/python/)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -3762,7 +4171,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.1"
+   "version": "3.12.2"
   },
   "nteract": {
    "version": "0.22.4"
diff --git a/20_LogitProbit.ipynb b/20_LogitProbit.ipynb
index 9b1e0c66..d1f93d65 100644
--- a/20_LogitProbit.ipynb
+++ b/20_LogitProbit.ipynb
@@ -92,13 +92,13 @@
     "\n",
     "    $$ 1-G(-z)=G(z)\\qquad\\; z=\\beta_0+\\beta_1x$$\n",
     "\n",
-    "    となる。またG(.)にどの分布を仮定するかによって，LogitモデルとProbitモデルに分けることができる。\n",
+    "    となる。また$G(.)$にどの分布を仮定するかによって，LogitモデルとProbitモデルに分けることができる。\n",
     "    \n",
-    "    * Logitモデル：eはLogistic分布に従うと仮定\n",
+    "    * Logitモデル：$e$はLogistic分布に従うと仮定\n",
     "\n",
     "        $$G(z)=L(z)=\\dfrac{\\exp(z)}{1+\\exp(z)}:\\quad\\text{(Logistic累積確率分布)}$$\n",
     "\n",
-    "    * Probitモデル：eは標準正規分布に従うと仮定\n",
+    "    * Probitモデル：$e$は標準正規分布に従うと仮定\n",
     "\n",
     "        $$G(z)=\\Phi(z)=\\text{標準正規分布の累積確率分布}$$\n",
     "\n",
@@ -1079,7 +1079,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.2"
   },
   "nteract": {
    "version": "0.23.1"
@@ -1099,5 +1099,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }