1_Basics_I.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 基本データ型と変数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div name=\"html-admonition\" style=\"font-size: 0.8em\">\n",
    "<input type=\"button\" onclick=\"location.href='https://translate.google.com/translate?hl=&sl=ja&tl=en&u='+window.location;\" value=\"Google translation\" style=\"color:#ffffff;background-color:#008080; height:25px\" onmouseover=\"this.style.background='#99ccff'\" onmouseout=\"this.style.background='#008080'\"/> in English or the language of your choice.\n",
    "</div><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 警告メッセージを非表示\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 最初の注意点"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### 半角と全角 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "> **半角**を基本としてコード（スペースも含めて）を書くこと。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次の２つケース以外で全角を使うとエラーが発生する。\n",
    "* 以下で説明する文字列型のデータ型の場合は全角を使っても構わない。\n",
    "* 半角の`#`の後であれば全角を使っても構わない（`Python`は`#`の後に続くコードを無視するためであり，よくコメントを書くのに使われる）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "例えば，次のコード・セルには半角の`10`の後に全角のスペースが紛れ込んでいるためエラーが発生している。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "10　"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "「全角スペース忍者」には要注意！\n",
    "\n",
    "しかし、`#`を使うと`#`の後は無視され実行されない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 10　"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不明瞭さをなくすために次の表現を使う。\n",
    "* `#`を付けてコードを実行できないようにすることを「コメントアウトする」（comment out）するいう。「コメント」して実行されないように（「アウト」）する、という意味。\n",
    "* `#`を取り除きコードを実行できるようにすることを「アンコメント」（uncomment）するという。「アン」は「コメント」の否定形。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 左詰め"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`Python`ではインデントが重要な役割を果たします。原則，コード・セルの中で左詰めでコードを書くようにすること。一方で，以下で説明するようにインデントが必須な場合（例えば，`for`ループや関数を定義する場合）もあり，その様な場合は**半角スペース4つ**を入れるのが慣例となっている。Jupyter Notebookでは`Tab`を押すことにより半角スペース4つが自動で挿入されるので覚えておこう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 括弧"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "コードでは括弧が多用されるが，次の呼称とする。\n",
    "* `()`：丸括弧（parentheses）\n",
    "* `[]`：角括弧（brackets）\n",
    "* `{}`：波括弧（braces, curly braces, curly brackets）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## ２つのデータ型と算術演算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### ２つのデータ型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`Python`には無数のデータ型があるが，まず基本となる2つを考える。\n",
    "* 整数型（`int`と表される; integerの略）\n",
    "* 浮動小数点型（`float`と表される）\n",
    "\n",
    "整数型とは文字通り`1`や`100`などの整数のことであり，浮動小数点型とは`0.2`や`11.666`などの小数を指す。`Python`では整数と小数を異なるデータ型として区別して扱うので，`1`と`1.0`はデータ型が異なることになる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "````{note}\n",
    "なぜ浮動小数点型を「少数」と呼ばないのか。数字の3.14を考えよう。表示方法によって次のように分けることができる。\n",
    "* 固定小数点型\n",
    "    \n",
    "    $$\n",
    "    3.14\n",
    "    $$\n",
    "    \n",
    "    この場合，小数点は3と1の間に固定されている。\n",
    "    \n",
    "* 浮動小数点型\n",
    "\n",
    "    $$\n",
    "    3.14\\times 10^0,\\quad 31.4\\times 10^{-1},\\quad 314.0\\times 10^{-10}\n",
    "    $$\n",
    "    \n",
    "    10の指数によって小数点が移動していることがわかる。\n",
    "    \n",
    "コンピュータは後者を利用しデータを2進法で表しているためである。\n",
    "````\n",
    "\n",
    "整数型の`1`を実行すると，`1`が返され表示されることになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "同様に不動小数点型の`1.0`を実行すると`1.0`が返される。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "データ型を確認するために`type()`という関数が用意されているので，それを使ってみよう（関数に関しては後述する）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "type(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "type(1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "整数型は`int`（integerの略），浮動小数点型は`float`（floating point numberの略）と表示されている。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "````{tip}\n",
    "1,000,000,000.0（10億）のような大きな数字は３桁ごとにコンマを入れると読みやすくなるが，`Python`では`,`の代わりに`_`を使うことができる。例えば，35億を`x`に割り当てる場合は次の様に書くことができる。\n",
    "```\n",
    "x = 3_500_000_000.0\n",
    "```\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### 計算機としての`Python`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "基本的な算術演算子として以下を挙げることができる。\n",
    "* `+`（加算）\n",
    "* `-`（減算）\n",
    "* `*`（乗算）\n",
    "* `/`（除算）\n",
    "* `**`（累乗）\n",
    "\n",
    "`a/b`を計算すると，整数部分である商と余り（0の場合もある）に分けることができる。\n",
    "* `//`（切り捨て除算）：整数部分を返す\n",
    "* `%`（剰余演算）：余り返す"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`a÷b`を考えよう。除算，切り捨て除算，剰余演算の関係は次の式で与えられる。\n",
    "\n",
    "```\n",
    "a = b X q + r\n",
    "```\n",
    "* `a`：割られる数\n",
    "* `b`：割る数\n",
    "* `q`：商（quotient）\n",
    "* `r`：剰余（余り, remainder）\n",
    "\n",
    "`q`を求めるには`//`を使い，`r`を求めるには`%`を使う。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "例を挙げて考えよう。まず整数型の四則演算と累乗を考えてみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "100 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "100 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "100 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "100 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "100 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここで気づくのは，商のみが浮動小数点型が返されている。更に，式の数値に不動小数点型が１つでも入ると，浮動小数点型が返されることになる。例えば，上のコードの`2`を`2.0`に変えて計算してみると，全て浮動小数点型が返ってくる（試してみよう。）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "数学では`()`の中が先に計算されるが，`Python`でも同じである。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "(100 - 50) / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に切り捨て演算を考えよう。`a/b`を計算すると，結果は整数部分である商と余り（`0`の場合もある）に分けることができるが，整数部分を返すのが切り捨て演算となる。次の例では整数型`7`を不動小数点型で割り，計算結果の整数部分を不動小数点型で返している（`2.0`ではなく`2`で割ると整数型`3`が返される。試してみよう）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "7 // 2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "切り捨て演算と関係が深いのが剰余演算`%`である。`x/y`の例を使うと，余り返すのが剰余演算となる。上と同じ例を使うと次の値が返される。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "7 % 2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この例では`7➗２.0=2.0余り1.0`となるため，`7 % 2.0`は`1.0`を返し，`5 // 2`は`2.0`を返すことになる。\n",
    "\n",
    "````{note}\n",
    "切り捨て演算と剰余演算には次の関係が成立する。\n",
    "\n",
    "```\n",
    "a　== (a//b)*(b) + (a%b)\n",
    "```\n",
    "ここで`==`は両辺が等しいことを確認するための演算子であり`True`を返すことになるが，詳細は後に説明するので両辺は等しいとだけ理解すれば良いだろう。`a,b>0`の場合は問題なく理解できると思う。しかし，`a`もしくは`b`もしくは両方が負の値を取るとエキゾチックな値になるので注意する必要がある。基本的に`//`は「床関数」と同義と考え，上の関係が満たされるように`%`の値が決まることになる。このサイトでは`a,b>0`のみを考える。\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## `=`による変数の割り当て"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### `=`の役割"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "数学では`=`は等号であり，両辺が等しいことを示すが，`Python`では別の意味で使われる。**変数にデータを割り当てる**場合にのみ使われる。即ち，「等号」ではなく「割り当て演算子」である。次の例では値`10`を変数`x`に割り当てている。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここで注意して欲しいのは，右辺の`10`が左辺の`x`に割り当てられている。`10 = x`とするとエラーが発生する。\n",
    "\n",
    "`x`の値を返す（表示する）には，`x`を書いたセルを実行するだけである。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "もちろん変数を使って算術演算を行うことも可能である。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 100\n",
    "y = 10\n",
    "z = x / y\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "このコードセルを実行すると，上から順番に１行目から評価されることになる。\n",
    "* １行目：`100`が`x`に割り当てられる。注意してほしい点は，上で`x = 10`が実行されており，`10`が`x`に割り当てられていいた。`x = 100`が実行されると同時に，`x = 10`の割り当ては無効になり，`100`が`x`に新たに割り当てられることになる。\n",
    "* ２行目：`10`が`y`に割り当てられる。\n",
    "* ３行目：`x / y`が評価され，その値が`z`に割り当てられる。\n",
    "* ４行目：`z`が評価され，値`10.0`が返される。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "上の説明では「代入する」ではなく「割り当てる」という表現を使ったが，その理由を解説しよう。簡単にいうと，`x`と`100`は全く別物であるためである。この点を理解するために、多くの品物が保管されている大きな倉庫を考えてみよう。倉庫の管理者はどの品物がどこに保管されているかを記録する在庫リストを作成し、そこに品物が保管されている棚を示す記号を記入するとしよう。この例を使うと、\n",
    "* `100`　→　倉庫の棚に保管されている品物\n",
    "* `x`　→　在庫リストに記載されている棚の記号\n",
    "\n",
    "となる。品物と棚の記号は別物である。`Python`では、品物である`10`がコンピューター内のメモリーの所定の場所に保存され、その場所を示すのが変数`x`となる。即ち、`x`は品物`10`の実態とは異なる単なる「参照記号」なのである。\n",
    "* `100`　→　PCのメモリーに保存されているデータ\n",
    "* `x`　→　参照記号\n",
    "\n",
    "この点を明確にするために、上のコードは「`100`を変数`x`に**割り当てる**」と考える。ここで`=`の**右辺**を先に読み，その次に**左辺**を読んでいることに注意しよう。`=`を右から左に読む（考える）ことを習慣づけることが、今後`Python`を勉強する上で重要となる。この点を示すために次のコードを考えてみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "「？」と思うかもしれない。暗に方程式として考えるためであろう（私がそうだった）。これを右から左に読むとスッキリする。\n",
    "1. 上で`100`を`x`に割り当てたが、問題のコードの右辺の`x`がその`100`である。`100`に`1`を加えたものが`101`であり、それが右辺である。\n",
    "1. `=`を使い右辺の`101`を左辺の`x`に割り当てている。この時点で、`100`の参照記号であった`x`は`101`の参照記号に変更される。\n",
    "\n",
    "実際に`x`を表示してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "このように`=`を使う度に，右辺のデータが左辺の参照記号に割り当てられたり，割り当てが変更されたりすることになる。「品物と参照記号の関係」は今の段階ではそれ程重要ではないが，先に進むにつれて重要性が増してくるので，今のうちにこのようなイメージを持つと良いだろう。\n",
    "\n",
    "```{note}\n",
    "`x = 101`を考えてみよう。Pythonの[公式ドキュメント](https://docs.python.org/3/reference/simple_stmts.html)では，このように`=`が使われるコードを assignment statement と呼んでいる。一方，[日本語版](https://docs.python.org/ja/3/reference/simple_stmts.html)は assignment statement を「代入文」と訳し，`=`を「代入演算子」と呼んでいる。しかし英語では assignment（割り当て）と substitution（代入）は異なる意味を持ち，前者が参照記号と実態の関係をより正確に反映していると考えられる。このサイトでは参照記号と実態の違いを強調するために，「代入する」ではなく「割り当てる（assign）」という表現を使っている。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true,
    "tags": [
     "remove-cell"
    ]
   },
   "source": [
    "### 複数の変数の同時割り当て"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "(sec:1-multiple-assignment)=\n",
    "### 複数の変数の同時割り当て"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`=`を使い１つの変数への割り当てを考えたが、同時に複数の変数への割り当ても可能である。次の例を考えよう。（`=`の右辺から読む！）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a, b, c = 3.14, 10_000, 999"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "左から順番に次のように割り当てをおこなっている。\n",
    "* `3.14`　→　`a`\n",
    "* `10_000`　→　`b`\n",
    "* `999`　→　`c`\n",
    "\n",
    "それぞれの変数を`,`で区切っていることにも留意しよう。同様に，`,`で区切って変数を並べて実行すると全てを丸括弧で挟んで返すことになる。ここでの`()`は，後に説明するタプルと呼ばれるデータ型を表している。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a, b, c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "また同時複数割り当ては，変数の値を入れ替える場合に便利である。次の例では`a`と`b`の値を入れ替えている。（右辺から読む！）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a, b = b, a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a, b, c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```{note}\n",
    "「複数の変数同時割り当て」と表現したが，[ここで](sec:3-unpacking)説明するタプルのアンパッキングと呼ばれる特徴を指している。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### 累算割り当て演算子"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "上で`x = x + 1`が出てきたが、これを短縮して`x += 1`と書くことができる。次のコードを考えようてみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "x += 1\n",
    "x += 1\n",
    "x += 1\n",
    "x += 1\n",
    "x += 1\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "コードセルの上から１行ずつ実行される。１行目で`10`が`x`に割り当てられる。２行目の`x += 1`は`x = x + 1`と同じなので，`x`は`11`になる。同様に，３行目で`x`は`12`になり同じ計算が６行目まで続くことになる。最後の`x`は割り当てられた値を表示するためのものであり，最終的に`15`になっていることがわかる。\n",
    "\n",
    "同様に他の算術演算子についても次の様に書くことができる。\n",
    "* `x = x - 1` $\\Rightarrow$ `x -= 1`\n",
    "* `x = x * 10` $\\Rightarrow$ `x *= 10`\n",
    "* `x = x / 10` $\\Rightarrow$ `x /= 10`\n",
    "* `x = x ** 2` $\\Rightarrow$ `x **= 2`\n",
    "* `x = x // 3` $\\Rightarrow$ `x //= 10`\n",
    "* `x = x % 2` $\\Rightarrow$ `x %= 2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x=2\n",
    "x **= 2\n",
    "x **= 2\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x=201\n",
    "x //= 2\n",
    "x //= 2\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "### 予約語"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "変数に値を割り当てることができるが，２つ注意点がある。\n",
    "1. 変数名をアルファベットで分かりやすい変数名にするのが可読性が高いコードを書くコツである。自分が書いたコードを数ヶ月後に読むと`x`や`y`が何の値を意味するのか分からない，という場合を避けるためである。\n",
    "1. 変数名を作る上で守らなくてはならないルールがある。\n",
    "    * `(a-z, A-Z)`もしくは`_`（アンダースコア）で始める。\n",
    "    * 最初の文字以外であれば`(a-z, A-Z)`と`_`に加え数字も可。\n",
    "    * 長さに制限はない。\n",
    "    * 小文字と大文字は異なる記号として認識される。\n",
    "    * 次の単語は特定の目的のために事前に定義されている「予約語」なため，変数名としては使えない（使うとエラーが発生する）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [],
   "source": [
    "import keyword\n",
    "keyword.kwlist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "これらに加え，\n",
    "\n",
    "* 変数の頭文字は小文字とする\n",
    "\n",
    "というのが慣例（エラーにはならない）であり，大文字で始まる変数は通常`class`と呼ばれるオブジェクトに使う。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 文字列型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "３つ目の基本データ型として文字列型を説明する。文字列は"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'国内総生産'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "のように`'`（シングル・クォーテーション）もしくは`\"`（ダブル・クォーテーション）で挟まれて定義される。どちらを使っても同じだが，クォートの中でクォートを使う必要がある場合は，それぞれ違ったものを使う。例えば，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'He said \"Python is very useful!\" to me.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この例では，外側は`'`と`'`を使っており，内側は`\"`と`\"`を使っている。データ型を確認してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "type('神戸大学')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`str`はstringの略である。次も文字列型となることには注意しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'0.1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "  type('0.1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "後述する数字の加算や除算などはできない`0.1`である。一方で文字列型専用の「加算」と「乗算」があるので，そちらも後述する。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "従って，`0.1`を使って算術演算をすることエラーが発生する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "1 + '1.0'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### `+`と`*`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`+`は文字列型と他のデータ型とは一緒に使えないが，文字列同士であれば使うことができる。`+`は文字列を結合することになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'一人当たり' + 'GDP'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'1.0' + '1.00'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "一方で`+`がなくても同じように文字列を結合して返すことになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'一人当たり' 'GDP'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`+`は文字列の結合を明示的にする目印と考えれば良いだろう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "また`*`を使うと文字列をリピートすることができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'(^o^)/   '*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'-★'*20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'😎🚀'*10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ブール型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### 説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次にブール型（boolでありbooleanの略）と呼ばれるデータ型を考える。ブール型には次の２つの値しかない。\n",
    "* `True`（真）\n",
    "* `False`（偽）\n",
    "\n",
    "名前が示すように「真偽」を示すのがブール型であり，`True`と`False`をブール値（真偽値, truth value）と呼ぶ。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "２つの値しかないが活躍の幅は広く，至る所で使うことになる。特に，ある条件が満たされる場合（`True`）と満たされない場合（`False`）を使い分けることで，様々な計算が可能となる。この点を説明するためには，比較演算子を説明するが，演算の結果として`True`もしくは`False`が返されることになる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### 比較演算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次の演算子を使うことにより，変数の真偽を確認することができる。\n",
    "* `==`（等号）\n",
    "* `!=`（等号不成立）\n",
    "* `<`（小なり）\n",
    "* `>`（大なり）\n",
    "* `<=`（小なりイコール，$\\leq$と同じ）\n",
    "* `>=`（大なりイコール，$\\geq$と同じ）\n",
    "\n",
    "最初の`==`は「等号」が２つ並んでいるが，`Python`ではこれが正しく「等号」を意味する。即ち，両辺が同値かどうかを確認することができるのである。例を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "10 == 10.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "データ型は異なるが，`10`という数値は同じなので`True`が返されている。次の例で`False`が返されるのも簡単に理解できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "10.1 == 10.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "一方，`!=`は`==`と逆の結果を返すことになる"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "10 != 10.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "10.1 != 10.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "残り４つの比較演算子は数学の不等号と同じように解釈すれば良いので問題ないだろう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "1 <= 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "1 >= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```{note}\n",
    "`=`が含まれる比較演算子は必ず２つの記号（`==`，`!=`，`>=`，`<=`）から構成されているので覚えておこう。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### ブール値（真偽値）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`10+5`は何？もちろん`15`である。では`10`は`True`と`False`のどっち？「えっ？どういうこと？」と考えるかもしれないが，答えは`True`である。「`Python`では全てがオブジェクトである」と言われるが（「オブジェクト」については後述する），全てのオブジェクトにはブール値がある。それを確かめる関数が`bool()`である。`10`のブール値を確認してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "bool(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "では何が`True`で何が`False`なのだろうか。\n",
    "\n",
    "**＜`False`と評価される値＞**\n",
    "* `False`（当たり前だがブール値の`False`）\n",
    "* `None`\n",
    "* `0`（整数型）\n",
    "* `0.0`（浮動小数点型）\n",
    "* `''`（空の文字列）\n",
    "* `[]`（空のリスト）\n",
    "* `()`（空のタプル）\n",
    "* `{}`（空の辞書）\n",
    "* `range(0)`\n",
    "* 等々\n",
    "\n",
    "`None`は「無」の状態を表す値である。データ型を調べると次のようになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "type(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "上のリストには説明していないものも含まれるが，`False`と評価されるのは「無」，「空」に対応する値と覚えておけば良いだろう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "bool(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "スペースも含めて，それら以外は全て`True`と評価される。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "bool(' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ついでに「経済学はおもしろい！」という意見について`Python`が同意するか尋ねてみよう😎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "bool('経済学はおもしろい！')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### ブール演算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "関連する演算としてブール演算がある。次の演算子となる。\n",
    "* `not`：でない（反転もしくは否定）\n",
    "* `and`：且つ\n",
    "* `or`：又は\n",
    "\n",
    "英語の意味のままなので，分かり易いのではないだろうか。注意する点は、ブール演算子が**複数同時**に使われる場合の計算の優先順位であり、次の順番となる。\n",
    "1. `not`\n",
    "2. `and`\n",
    "3. `or`\n",
    "\n",
    "`not`が一番優先され、`or`の優先順位が一番低い。この順番を忘れると意図せぬ間違いにつながるので、`()`を使うことを推奨する。\n",
    "\n",
    "例を考えるために，まず次の変数を設定しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = -1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### `not`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "まず`not`から考えよう。「否定」なので次の様な挙動となる。\n",
    "* `True`の前に置くと`False`を返す。\n",
    "* `Flase`の前に置くと`True`を返す。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "not (a > 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この結果は次のように解釈できる。まず`()`の中が優先的に評価され`False`が返される。更に，`not`で否定されるので結果は`True`となる。（`(not a) > 1`は異なる結果となるので注意しよう。）次の結果も同様に解釈することができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "not (a < 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### `and`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に`and`を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "「`True`且つ`True`」なので全体では`True`となる。簡単に理解できるはずである。次も基本的には同じである。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "(a > 0) and (b < 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次の例には`False`が入っている。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "False and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "(a < 0) and (b < 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### `or`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "簡単なので解説は不要であろう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "(a > 0) and (b > 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### `and`と`or`は何を返しているのか"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "上の例を見ると`and`と`or`は`True`もしくは`False`のみを返しているような印象を持つかも知れないが，実はそうではない。次の条件に従って，`and`は左の変数もしくは右の変数を返している。`or`も同様である。\n",
    "\n",
    "| 演算      |        結果                         |\n",
    "|:--------:|:------------------------------------|\n",
    "| x  or y  | x  が`False`なら y, そうでなければ x を返す  |\n",
    "| x  and y | x   が`False`なら   x , そうでなければ y を返す |\n",
    "\n",
    "ここで`True`か`False`は，上で説明したブール値が使われる。次の例を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'' or 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "空の文字列`''`のブール値は`False`になるため，上の表に従って`5`が返されている。上の表に従うと，次の例も理解できるだろう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'' and 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### ブール値と数値"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "全てのオブジェクトにはブール値があることを説明した。一方で，ブール値は次の数値と同値して扱われる。\n",
    "* `True`　→　`1`もしくは`1.0`\n",
    "* `False`　→　`0`\n",
    "\n",
    "コードで確かめてみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "True == 1 # Trueは１なのでTrueを返す"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "False == 0 # Falseは0なのでTrueを返す"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "True + True + True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "True * 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "今の段階でこの用途は明確ではないと思うが，データを扱う際は非常に便利に感じることだろう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 精度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "「コンピューターは非常に正確だ」というイメージを持っていないだろうか（私がそうだった）。実は，全くその逆である。次の計算をしてみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "0.3 == 0.1 + 0.1 + 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "「えっ！」と思うかもしれない。`False`ということは，`Python`は左辺と右辺の値は**異なる**と判断している。明らかに「おかしな」結果である。\n",
    "\n",
    "なぜこうなるかを説明するために$1/3$を考えよう。\n",
    "\n",
    "$\\dfrac{1}{3}=0.333333333333333333\\cdots\\cdots\\cdots$\n",
    "\n",
    "永遠に3が続く。コンピュータのメモリの容量は有限であるため、無限に続く3をメモリに保存しすることは不可能である。従って、どこかで切断して$1/3$の近似値を保存する必要がある。これと同じようなことを`Python`は行っている。10進法の数字を2進法に変換し，計算結果を10進法に変換し表示する。その際、多くの数字は$1/3$と同じように近似値となる。即ち，`0.1`と表示されていても，`Python`は実際には近似値を使っているため，誰でもおかしいと思う結果が発生することになる。\n",
    "\n",
    "では`0.1`と`0.3`の近似値を表示してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "print('0.1の近似値\\n','-'*9,'\\n',format(0.1, '.55f'),sep='')\n",
    "print('\\n\\n0.3の近似値\\n','-'*9,'\\n',format(0.3, '.55f'),sep='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "format(0.9, '.55f')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "近似値と`0.1`もしくは`0.3`との差は非常に小さく，殆どの計算には支障がない程度になっている。これで`0.3 == 0.1 + 0.1 + 0.1`が`False`を返す理由が分かったが，この事から次のことが言える。\n",
    "> 浮動小数点型に`==`を使い真偽を確かめるのは**危険**である。使わないように！\n",
    "\n",
    "````{note}\n",
    "では２つの浮動小数点型の真偽をどのように確かめれば良いのだろうか。２つの方法を紹介する。\n",
    "1. [このセクション](sec:V-solow)で説明する`math`モジュールにある`isclose`関数を使うことができる。この関数は２つの値が十分に近い場合は`True`を返す。例えば，次のコードは`True`を返すことになる。\n",
    "```\n",
    "import math\n",
    "math.isclose(0.3, 0.1+0.1+0.1)\n",
    "```\n",
    "1. [この章](chap:numpy)で説明する`NumPy`と呼ばれる外部パッケージに含まれる`isclose()`関数を使うことができる。この関数も２つの値が十分に近い場合は`True`を返す。次のコードは`True`を返すことになる。\n",
    "```\n",
    "import numpy as np\n",
    "np.isclose(0.3, 0.1+0.1+0.1)\n",
    "```\n",
    "````\n",
    "\n",
    "上の例では小さな値を考えたが，大きい値の場合にも類似する問題が存在する。次を計算してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "2.0**52"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "2.0**52 == 2.0**52 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この結果は期待どおりであるが，次の例はそうではない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "2.0**53"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "2.0**53 == 2.0**53 + 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "これは浮動小数点型で正確に表示できる最大の数（有効桁数）に制限があるために発生する。`2.0**53`の例は有効桁数を超えているため対応不可能になり間違った結果を返している。一方，整数型には有効桁数に制限はないため，このような問題は発生しない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "2**53 == 2**53 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## コンテナデータ型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上では基本となるデータ型を説明したが，そのような（それらだけではないが）データ型の集合となるデータ型も存在する。それがコンテナデータ型（Container Datatypes）と呼ばれるものであり，次の３種類について説明する\n",
    "* リスト（`list`）\n",
    "* タプル（`tuple`，「チュープル」とも呼ばれる）\n",
    "* 辞書（`dict`，dictionaryの略）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### リスト"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "リストは最も基本となるコンテナデータ型であり，次の特徴を持っている。\n",
    "* `[]`を使って作成する。\n",
    "* 要素は`,`で区切る。\n",
    "* 要素を変更することが可能（mutable）。\n",
    "\n",
    "例としてショッピング・リストを考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "['bread', 'egg', 'ham']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "もちろん日本語でも構わない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "['パン', '玉子', 'ハム']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "その価格を表すリストも作成しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[100, 300, 250]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "もちろん変数に割り当てることも可能である。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "price_list = [100, 300 , 250]\n",
    "price_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`type()`関数を使ってデータ型を確認してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(price_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "リストのデータ型は`list`と表示されることがわかる。また異なるデータ型が要素として入ることも可能である。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "['egg', 100, True]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これもショッピングに関する情報だと考えることもできる。商品は`egg`は，価格は`100`，購入するかどうかは`True`といった具合である。\n",
    "\n",
    "要素が１つのリストの生成も可能である（玉子の価格のみ）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "空のリストも作成可能であり，白紙ショッピング・リストと考えれば良いだろう。後々活躍することになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "またリストの中にリストや他のデータ型（以下で説明するタプルや辞書など）を入れることも可能だ。ショッピング・リストの例から離れるが次の様に書くことできる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[0, [], [1], [2,3],[4,5,6]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "整数型の`0`，空のリスト，そして要素の数が異なるリストが入っている。\n",
    "\n",
    "次の例は行列のように要素が並んでいる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "[[1,2,3],\n",
    " [4,5,6],\n",
    " [7,8,9]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### `+`と`*`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "リストにも`+`を使うことができる。文字列と同じように，複数のリストを結合することができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "[100,300,250] + ['egg','ham','bread']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "また`*`は整数型の値を使うことにより，要素をリピートして一つのリストとして返すことになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "['egg', 100] * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "[['egg']+[100], ['ham']*2, 'bread']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### タプル"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "主な特徴：\n",
    "* 基本的には`()`を使って作成する。\n",
    "    * 実はコンマ`,`によってタプルは定義されるため`(`と`)`は必須ではない。\n",
    "* 要素は`,`で区切る。\n",
    "* 要素を変更すること不可能（immutable）。\n",
    "\n",
    "まずリストで使ったショッピング・リストの例を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "('egg', 'ham', 'bread')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "変数に割り当てて，データ型を確認してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "price_tuple = (100, 300 , 250)\n",
    "\n",
    "type(price_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "タプルのデータ型は`tuple`と表示される。次の例では異なるデータ型が要素として入っている。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "('egg', 100, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "上でも触れたが，タプルは`(`と`)`が無くても作成できる。例えば、次のコードでもタプルとなる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "'egg', 100, True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "タプルは，コンマ`,`によってタプルは定義されるためであり，`()`はタプルを明確にするためと考えて良いだろう。\n",
    "\n",
    "上の例が示すように，コードセルで`,`を使いコードを書き実行するとタプルが変えることがわかる。例えば，次のコードもタプルを返し，個々の要素がそれぞれのコードの実行結果となっている。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 3\n",
    "\n",
    "True * 3 == y, x/y, type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "また要素が１つのタプルも生成可能だが，その場合も必ず`,`を付ける事を忘れないように。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "('1',)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "例えば，次のコードは整数型の`10`になる。`type()`関数を使って確認してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "(10), type((10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "２つの実行結果がタプルとして返されている。\n",
    "\n",
    "タプルの中にタプルや他のデータ型を入れることも可能だ。例えば，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "(0, ['egg', 100], (3,4,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここで`['egg', 100]`はリストである。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `+`と`*`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "リストと同じように，`+`は結合に使うことができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(100, 300, 250) + ('egg','ham','bread')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "また`*`を使うと要素を整数回リピートしたタプルを作成することができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "('egg', 100) * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 辞書"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "主な特徴：\n",
    "* `{}`を使って作成する。\n",
    "* 辞書（dictionary）はキー（key）と値（value）のペアが１つの要素となる。\n",
    "* １つの要素は`:`を挟んで左側にキーがあり，右側に値がくる。全てを`{}`で囲み辞書を定義する。\n",
    "* キーは変更不可（immutable）だが，値は変更可能（mutable）\n",
    "\n",
    "ショッピング・リストの例を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{'egg':100, 'ham':300, 'bread':250}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "各要素は商品と価格のペアになっている。１つ目の要素は`'egg':100`であり，`'egg'`がキーとなり，`100`が値である。２つ目の要素のキーは`'ham'`，値は`300`となっている。今の段階では辞書を使う目的が不明確でしっくりこないと思うが，勉強を進めるととてもパワフルなツールだと気づくだろう。\n",
    "\n",
    "変数に割り当てて，データ型を調べてみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic = {'失業率':0.05, 'インフレ率':0.01}\n",
    "\n",
    "type(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "辞書のデータ型は`dict`であることがわかる。\n",
    "\n",
    "値は様々なデータ型を設定できる。リストやタプル，辞書も値として指定できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{'a':(1,2), 'b':[3,4], 'c':True, 'd':{'県':'兵庫', '市':'神戸'}}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "この特性を利用して，学生の成績を格納しておくことも考えられる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mark = {'1234567e':{'経済学':95, '統計学':83, 'ゼミ':100},\n",
    "        '7654321e':{'経済学':65, '統計学':73, 'ゼミ':85},\n",
    "        '1234321e':{'経済学':60, '統計学':99, 'ゼミ':65}}\n",
    "mark"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "キーは変更不可能な次のデータ型が使える。\n",
    "* 文字列型\n",
    "* 整数型\n",
    "* 不動小数点型\n",
    "* タプル"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{'egg':100, 5:100, 1.001: False, (1,2):'B'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 辞書の結合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "リストとタプルの結合には`+`を使うことができたが，辞書では使えない。その代わりに，`Python`3.9以降であれば`|`（「パイプ」と読む）が使える。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x = {'egg':100, 'ham':100}\n",
    "y = {'ham':300, 'bread':250} \n",
    "\n",
    "x | y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`x`には`'ham':100`があり，`y`には`'ham':300`がある。結合すると，`|`の右側にある`x`の`'b'`が上書きされていることに注意しよう。\n",
    "\n",
    "`Python`3.8以前であれば次の構文となる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "{**x, **y}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 所属検査演算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "次の演算子を使うと所属関係を確認することができる。\n",
    "* `in`：あるデータがコンテナデータの要素であれば`True`，そうでなければ`False`を返す。\n",
    "* `not in`：`in`の結果を反転させたブール値を返す。\n",
    "\n",
    "例を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [['egg', 'ham'], 100, 300]\n",
    "\n",
    "tpl = (('egg', 'ham'), 100, 300)\n",
    "\n",
    "dic = {'egg':100, 'ham':300}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`100`が`lst`に含まれるかは次のコードで確認できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "100 in lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`not in`の場合は次のようになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "100 not in lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "入れ子の場合は，次のような挙動となる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'egg' in lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "['egg','ham'] in lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "タプルの場合も同じである。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "100 in tpl, 100 not in tpl, 'egg' in tpl, ('egg','ham') in tpl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "辞書の場合は，キーの確認に対応している。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'egg' in dic, 'egg' not in dic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`in`演算子は文字列にも使うことができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'egg' in 'breadeggham'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## まとめ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**＜基本データ型＞**\n",
    "\n",
    "|     データ型 | 例                      |\n",
    "| ----------- | ----------------------- |\n",
    "|       整数型（`int`） | `10`                      |\n",
    "| 不動小数点型（`float`） | `10.0`                    |\n",
    "|     文字列型（`str`） | `'10.0'` もしくは `\"10.0\"`  |\n",
    "|     ブール型（`bool`） | `True` もしくは `False` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**＜算術演算＞**\n",
    "\n",
    "|     算術演算子 | 例      | 動作・戻り値 |\n",
    "| ----------- | ------ |----|\n",
    "| `+` | `10+2`　→　`12` | 加算 |\n",
    "| `-` | `10-2`　→　`8`  | 減算 |\n",
    "| `*` | `10*2`　→　`20` | 乗算 |\n",
    "| `/` | `10/2`　→　`5.0`| 除算 |\n",
    "| `**` | `10**2`　→　`100`| 累乗 |\n",
    "| `//` | `11//2`　→　`5`| 剰余演算 |\n",
    "| `%` | `11%2`　→　`1`| 切り捨て除算 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**＜文字列＞**\n",
    "\n",
    "|  文字列型に使う | 例      | 動作・戻り値 |\n",
    "| ----------- | ------ |----|\n",
    "| `+` | `'神戸' + '大学'`　→　`'神戸大学'` | 結合 |\n",
    "| `+`がなくても | `'神戸' '大学'`　→　`'神戸大学'`  | 結合 |\n",
    "| `*` | `'★'*5`　→　`'★★★★★'` | 文字列を整数個返す |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**＜比較演算＞**\n",
    "\n",
    "|  比較演算子 | 例      | 意味 |\n",
    "| ----------- | ------ |----|\n",
    "| `==` | `10 == 10`　→　`True` | 等号 |\n",
    "| `!=` | `11 != 10`　→　`True`  | 等号不成立 |\n",
    "| `<` | `5 < 10`　→　`True` | 小なり |\n",
    "| `>` | `10 > 5`　→　`True` | 大なり |\n",
    "| `<=` | `5 <= 10`　→　`True` | 小なりイコール |\n",
    "| `>=` | `10 >= 5`　→　`True` | 大なりイコール |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**＜ブール演算＞**\n",
    "\n",
    "|  ブール演算子 | 例      | 意味 |\n",
    "| ----------- | ------ |----|\n",
    "| `not` | `not True`　→　`False` | 否定 |\n",
    "| `and` | `True and False`　→　`False`  | 且つ |\n",
    "| `or` | `False or True`　→　`True` | 又は |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**＜コンテナデータ型＞**\n",
    "\n",
    "|     データ型 | 例       |\n",
    "| ----------- | ------- \n",
    "| リスト | `[0,1,3]`    |\n",
    "| タプル | `(0,1,3)`    |\n",
    "| 辞書 | `{'a':0, 'b':1}`    |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**＜コンテナデータ型の結合＞**\n",
    "\n",
    "|     データ型 | 例       | 結合方法 |\n",
    "| ----------- | ------- |---|\n",
    "| リスト | `x = [0,10]`<br>`y = [30]` |  `x + y`　→　`[0,10,30]` |\n",
    "| タプル | `x = (0,10)`<br>`y = (30,)` |  `x + y`　→　`(0,10,30)` |\n",
    "| 辞書 | `x = {'a':0}`<br>`y = {'b':10}` |  `x \\| y` 又は `{**y,**x}`　→　`{'a':0,'b':10}` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**＜所属確認演算＞**\n",
    "\n",
    "|  ブール演算子 | 例      | 演算 |\n",
    "| ----------- | ------ |----|\n",
    "| `in` | `x = [1,2]` | `2 in x`　→　`True` |\n",
    "| `not in` | `x = [1,2]` | `2 not in x`　→　`False` |"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}