├── .gitignore ├── README.md ├── .DS_Store ├── pdfs ├── python-fig1.pdf └── python-fig2.pdf ├── images ├── python-fig1.png └── python-fig2.png └── notebooks ├── exams ├── 14-numpy2-exam.ipynb ├── 11-python1-exam.ipynb ├── 13-numpy1-exam.ipynb ├── 12-python2-exam.ipynb └── 15-matplotlib-exam.ipynb ├── 10-my-first-notebook.ipynb ├── 14-numpy2.ipynb ├── 12-python2.ipynb ├── 11-python1.ipynb ├── 13-numpy1.ipynb └── 15-matplotlib.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 京都情報大学院大学 数学コース 2 | コンテンツ配布用 3 | 4 | 5 | -------------------------------------------------------------------------------- /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/makaishi2/kcgi-course-contents/master/.DS_Store -------------------------------------------------------------------------------- /pdfs/python-fig1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/makaishi2/kcgi-course-contents/master/pdfs/python-fig1.pdf -------------------------------------------------------------------------------- /pdfs/python-fig2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/makaishi2/kcgi-course-contents/master/pdfs/python-fig2.pdf -------------------------------------------------------------------------------- /images/python-fig1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/makaishi2/kcgi-course-contents/master/images/python-fig1.png -------------------------------------------------------------------------------- /images/python-fig2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/makaishi2/kcgi-course-contents/master/images/python-fig2.png -------------------------------------------------------------------------------- /notebooks/exams/14-numpy2-exam.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Numpy2 課題" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "重回帰用の学習データx2に更に、項目'CRIM'と'ZN'を追加したデータx4を作って下さい。" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 1, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "# 必要ライブラリimport\n", 24 | "import numpy as np\n", 25 | "from sklearn.datasets import load_boston\n", 26 | "\n", 27 | "boston = load_boston()\n", 28 | "x_org, yt = boston.data, boston.target\n", 29 | "feature_names = boston.feature_names\n", 30 | "\n", 31 | "x_data = x_org[:,feature_names == 'RM']\n", 32 | "x = np.insert(x_data, 0, 1.0, axis=1)\n", 33 | "\n", 34 | "x_add = x_org[:,feature_names == 'LSTAT']\n", 35 | "x2 = np.hstack((x, x_add))" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 2, 41 | "metadata": {}, 42 | "outputs": [ 43 | { 44 | "name": "stdout", 45 | "output_type": "stream", 46 | "text": [ 47 | "(506, 3)\n", 48 | "[[1. 6.575 4.98 ]\n", 49 | " [1. 6.421 9.14 ]\n", 50 | " [1. 7.185 4.03 ]\n", 51 | " [1. 6.998 2.94 ]\n", 52 | " [1. 7.147 5.33 ]]\n" 53 | ] 54 | } 55 | ], 56 | "source": [ 57 | "print(x2.shape)\n", 58 | "print(x2[:5,:])" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [ 67 | "# ここから先にx4作成用のコードを書いて下さい\n" 68 | ] 69 | } 70 | ], 71 | "metadata": { 72 | "kernelspec": { 73 | "display_name": "Python 3", 74 | "language": "python", 75 | "name": "python3" 76 | }, 77 | "language_info": { 78 | "codemirror_mode": { 79 | "name": "ipython", 80 | "version": 3 81 | }, 82 | "file_extension": ".py", 83 | "mimetype": "text/x-python", 84 | "name": "python", 85 | "nbconvert_exporter": "python", 86 | "pygments_lexer": "ipython3", 87 | "version": "3.7.3" 88 | } 89 | }, 90 | "nbformat": 4, 91 | "nbformat_minor": 2 92 | } 93 | -------------------------------------------------------------------------------- /notebooks/exams/11-python1-exam.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Python入門1 課題" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "#### 問題1 \n", 15 | "次のlist1を元に、[14, 12, 10]という配列を作って下さい。\n" 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 3, 21 | "metadata": {}, 22 | "outputs": [], 23 | "source": [ 24 | "# リストの定義\n", 25 | "\n", 26 | "list1 = [2, 4, 6, 8, 10, 12, 14]" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 6, 32 | "metadata": {}, 33 | "outputs": [ 34 | { 35 | "name": "stdout", 36 | "output_type": "stream", 37 | "text": [ 38 | "[14, 12, 10]\n" 39 | ] 40 | } 41 | ], 42 | "source": [ 43 | "# 解答\n", 44 | "\n", 45 | "list2 = list1[]\n", 46 | "print(list2)" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "#### 問題2 \n", 54 | "2次元のタプルは``(0,1)``、3次元のタプルは``(0,1,2)``のように表現しますが、 \n", 55 | "1次元のタプルは``(0)``ではなく``(0,)``と後ろにカンマをつけて表現します。\n", 56 | "その理由を簡単に説明して下さい。\n" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": {}, 63 | "outputs": [], 64 | "source": [] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": null, 69 | "metadata": {}, 70 | "outputs": [], 71 | "source": [] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": null, 76 | "metadata": {}, 77 | "outputs": [], 78 | "source": [] 79 | } 80 | ], 81 | "metadata": { 82 | "kernelspec": { 83 | "display_name": "Python 3", 84 | "language": "python", 85 | "name": "python3" 86 | }, 87 | "language_info": { 88 | "codemirror_mode": { 89 | "name": "ipython", 90 | "version": 3 91 | }, 92 | "file_extension": ".py", 93 | "mimetype": "text/x-python", 94 | "name": "python", 95 | "nbconvert_exporter": "python", 96 | "pygments_lexer": "ipython3", 97 | "version": "3.7.3" 98 | } 99 | }, 100 | "nbformat": 4, 101 | "nbformat_minor": 2 102 | } 103 | -------------------------------------------------------------------------------- /notebooks/exams/13-numpy1-exam.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Numpy入門　課題" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "#### 問題1\n", 15 | "一次元配列のshapeの結果は``(3,)``のように後ろにカンマが付いた形で返ってきます。 \n", 16 | "なぜ``(3)``のような形にならないのか説明して下さい。\n", 17 | "(前回の課題の復習です)\n" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 2, 23 | "metadata": {}, 24 | "outputs": [ 25 | { 26 | "name": "stdout", 27 | "output_type": "stream", 28 | "text": [ 29 | "(3,)\n", 30 | "(2, 3)\n" 31 | ] 32 | } 33 | ], 34 | "source": [ 35 | "# (例)\n", 36 | "import numpy as np\n", 37 | "\n", 38 | "v = np.array([1,2,3])\n", 39 | "print(v.shape)\n", 40 | "\n", 41 | "M = np.array([[1,2,3],[4,5,6]])\n", 42 | "print(M.shape)" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": null, 48 | "metadata": {}, 49 | "outputs": [], 50 | "source": [ 51 | "# 解答1\n", 52 | "#\n", 53 | "#\n", 54 | "#\n", 55 | "#" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "#### 問題2\n", 63 | "\n", 64 | "np.random.randn関数と、スカラー和、スカラー積の仕組みを利用して \n", 65 | "平均4、標準偏差2の乱数を要素をして持つ 2x3 の行列Nを作って下さい。 \n", 66 | "\n", 67 | "(ヒント)平均0、標準偏差1の乱数を2倍して4を足すと、上記の乱数になります。" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 3, 73 | "metadata": {}, 74 | "outputs": [ 75 | { 76 | "name": "stdout", 77 | "output_type": "stream", 78 | "text": [ 79 | "[[4.51744641 4.49728235 4.51347257]\n", 80 | " [4.76739818 5.15286872 5.88631157]]\n" 81 | ] 82 | } 83 | ], 84 | "source": [ 85 | "# 解答2\n", 86 | "\n", 87 | "Z = np.random.rand(2,3)\n", 88 | "N = \n", 89 | "\n", 90 | "print(N)" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [] 99 | } 100 | ], 101 | "metadata": { 102 | "kernelspec": { 103 | "display_name": "Python 3", 104 | "language": "python", 105 | "name": "python3" 106 | }, 107 | "language_info": { 108 | "codemirror_mode": { 109 | "name": "ipython", 110 | "version": 3 111 | }, 112 | "file_extension": ".py", 113 | "mimetype": "text/x-python", 114 | "name": "python", 115 | "nbconvert_exporter": "python", 116 | "pygments_lexer": "ipython3", 117 | "version": "3.7.3" 118 | } 119 | }, 120 | "nbformat": 4, 121 | "nbformat_minor": 2 122 | } 123 | -------------------------------------------------------------------------------- /notebooks/exams/12-python2-exam.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Python入門2 課題" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "\n", 15 | "次のような数値リストをrange関数を使って作ってください\n", 16 | "" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "#### 問題1 \n", 24 | "```\n", 25 | "list1 = [10, 20, 30, .., 100] \n", 26 | "```" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "# 解答1\n", 36 | "\n", 37 | "# 次のrange関数の引数をコーディングします。\n", 38 | "list1 = range()\n", 39 | "\n", 40 | "# 結果確認\n", 41 | "print(list(list1))" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "#### 問題2 \n", 49 | "\n", 50 | "```\n", 51 | "list2 = [20, 19, 18.., 1] \n", 52 | "```" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": {}, 59 | "outputs": [], 60 | "source": [ 61 | "# 解答2\n", 62 | "\n", 63 | "# 次のrange関数の引数をコーディングします。\n", 64 | "list2 = range()\n", 65 | "\n", 66 | "# 結果確認\n", 67 | "print(list(list2))" 68 | ] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "#### 問題3\n", 75 | "\n", 76 | "\n", 77 | "ネストのかかったif構文の実装\n", 78 | "\n", 79 | "\n", 80 | "二次元変数x[0], x[1] があり、それぞれTrueかFalseの値を取るものとします。 \n", 81 | "次のような条件でprint文を出力するプログラムを組んでください。 \n", 82 | "\n", 83 | "次のような条件でprint文を出力するプログラムを組んでください。 \n", 84 | "(注) 条件をandでつないで一気に書くやりかたもありますが、 \n", 85 | "今回は練習のためネストのかかった2段階のif文でコーディングしてください。\n", 86 | "\n", 87 | "x[0]==True, x[1]==True -> very good \n", 88 | "x[0]==True, x[1]==False -> good \n", 89 | "x[0]==False, x[1]==True -> bad \n", 90 | "x[0]==False, x[1]==False -> very bad " 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [ 99 | "# 解答3 (以下の4つの条件それぞれでテストしてみます)\n", 100 | "\n", 101 | "x = [True, True]\n", 102 | "#x = [True, False]\n", 103 | "#x = [False, True]\n", 104 | "#x = [False, False]\n", 105 | "\n", 106 | "if # 以下にif文のコーディングをして下さい\n", 107 | "\n" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "#### 問題4\n", 115 | "\n", 116 | "リスト内包表記の実装\n", 117 | "\n", 118 | "\n", 119 | "``q_list = [0, 1, 2, 3, 4, 5, 6, 7]``\n", 120 | "というlist変数を元に次のlist変数を作って下さい。\n", 121 | "\n", 122 | "``list4 = [0, 1, 4, 9, 16, 25, 36, 49]``\n", 123 | "\n", 124 | "ヒント $x^2$はPythonでは ``x**2`` で表します。 " 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": null, 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [ 133 | "# 解答4\n", 134 | "\n", 135 | "# 次の行でリスト内包表記を行います\n", 136 | "list4 = []\n", 137 | "\n", 138 | "# 結果の確認\n", 139 | "print(list4)" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "#### 問題5\n", 147 | "問題4同様に q_list を元に、\n", 148 | "``list5 = [0, 4, 16, 36]``\n", 149 | "というlist変数を作って下さい。\n", 150 | "\n", 151 | "ヒント 「x を y で割った余り」はPythonでは ``x%y`` で表します。\n" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": {}, 158 | "outputs": [], 159 | "source": [ 160 | "# 解答5\n", 161 | "\n", 162 | "# 次の行でリスト内包表記を行います\n", 163 | "list5 = []\n", 164 | "\n", 165 | "# 結果の確認\n", 166 | "print(list5)" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [] 175 | } 176 | ], 177 | "metadata": { 178 | "kernelspec": { 179 | "display_name": "Python 3", 180 | "language": "python", 181 | "name": "python3" 182 | }, 183 | "language_info": { 184 | "codemirror_mode": { 185 | "name": "ipython", 186 | "version": 3 187 | }, 188 | "file_extension": ".py", 189 | "mimetype": "text/x-python", 190 | "name": "python", 191 | "nbconvert_exporter": "python", 192 | "pygments_lexer": "ipython3", 193 | "version": "3.7.3" 194 | } 195 | }, 196 | "nbformat": 4, 197 | "nbformat_minor": 2 198 | } 199 | -------------------------------------------------------------------------------- /notebooks/10-my-first-notebook.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Jupyter Notebookの操作方法\n", 10 | "\n", 11 | "左側に``In [ ]``と表示されている領域のことを「セル」といいます。 \n", 12 | "Jupyter Notebookによる操作の原理は次のとおりです。\n", 13 | "\n", 14 | "* プログラム実行は**「セル」**の単位で行います。\n", 15 | "\n", 16 | "\n", 17 | "* 実行する場合は、実行対象のセルを選択した状態で**「Run」アイコン**のクリック、または**[Shift] + [Enter]**入力を行います。\n", 18 | "\n", 19 | "\n", 20 | "* 実行結果はカーネル上に記憶されています。別のセルから**計算結果を保存した変数**や、**定義した関数**が参照できるということです。\n", 21 | "\n", 22 | "\n", 23 | "* 実行結果が画面表示を含むものであった場合(グラフを含む)、結果は**実行したセルの直下**に表示されます。\n", 24 | "\n", 25 | "\n", 26 | "* Notebookファイルを保存する場合、**実行結果も含めた形**で保存されます。 \n", 27 | "外部ファイルとして保存するための手順はメニューから**「File」->「Download as」->「Notebook (.ipynb)」**です。\n", 28 | "\n", 29 | "\n", 30 | "* 過去の実行結果をご破算にしたい場合は、**「カーネル再起動」**を行います。 \n", 31 | "メニューから実行する場合は**「Kernel」-> 「Restart」**を選択します。\n", 32 | "\n", 33 | "\n", 34 | "* カーネルがクリアされても画面上の実行結果は残っています。 \n", 35 | "画面上の実行結果を含めてご破算にしたい場合は、**「Kernel」->「Restart & Clear Output」**を選択します。\n" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "### 最初の課題 (新規セルから実行)\n", 43 | "\n", 44 | "次のセルに ``1+1``を入力し、**「Run」アイコン**クリックまたは**[Shift]+[Enter]**でセルの実行を行って下さい。" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": null, 50 | "metadata": {}, 51 | "outputs": [], 52 | "source": [] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "既存のノートブックに新規セルを挿入したい場合、画面上部の「+」アイコンをクリックするか、\n", 59 | "メニューから**「Insert」->「Insert Cell Above**」または**「Inser Cell Below」**を選択します。" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "## 事前定義のプログラムの実行\n", 67 | "\n", 68 | "Notebokから読み込んだ時点でセルに入力済みのプログラムがPythonとして有効なものであった場合、 \n", 69 | "そのセルを選択した状態で「セルの実行」を行うことで、事前に定義してあるPythonプログラムを簡単に動かすことができます。\n", 70 | "\n" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": {}, 76 | "source": [ 77 | "### ２番目の課題 (既存セルから実行)\n", 78 | "\n", 79 | "次のPythonコード事前定義済みセルを選択した状態で、**「Run」**アイコンクリックまたは**[Shift]+[Enter]**でセルの実行を行って下さい。 \n", 80 | "(参考のため解説をコメントとして書いておきましたが、現段階でコードの意味はわからなくていいです。操作方法のみ理解するようにして下さい。)" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": null, 86 | "metadata": {}, 87 | "outputs": [], 88 | "source": [ 89 | "# f(x, y)= x^2 + y^2のグラフの3次元表示 \n", 90 | "\n", 91 | "# グラフ表示のために必要な宣言\n", 92 | "%matplotlib inline\n", 93 | "\n", 94 | "# 必要ライブラリのインポート\n", 95 | "import numpy as np\n", 96 | "import matplotlib.pyplot as plt\n", 97 | "from mpl_toolkits.mplot3d import Axes3D \n", 98 | "from matplotlib import cm\n", 99 | "\n", 100 | "# 関数定義\n", 101 | "def func(x,y):\n", 102 | " return x**2 + y**2\n", 103 | "\n", 104 | "# x, yの座標値計算\n", 105 | "x = np.arange(-5,5,0.05)\n", 106 | "y = np.arange(-5,5,0.05)\n", 107 | "\n", 108 | "# 座標値を元にメッシュ状に(x, y)の値を生成\n", 109 | "X, Y = np.meshgrid(x,y)\n", 110 | "\n", 111 | "# (x, y)の値に対して関数値の計算\n", 112 | "Z = func(X,Y)\n", 113 | "\n", 114 | "# グラフ機能の呼出し\n", 115 | "fig = plt.figure()\n", 116 | "\n", 117 | "# ３次元グラフの宣言\n", 118 | "ax = Axes3D(fig)\n", 119 | "\n", 120 | "# 関数の三次元グラフ描画\n", 121 | "ax.plot_surface(X,Y,Z,cmap=cm.coolwarm) \n", 122 | "\n", 123 | "# グラフの画面表示\n", 124 | "plt.show()" 125 | ] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": {}, 130 | "source": [ 131 | "### 3番目の課題 (カーネル再起動の確認)\n", 132 | "\n", 133 | "**3-A**: 次のセルに\n", 134 | "\n", 135 | "```\n", 136 | "print(func(2, 1))\n", 137 | "```\n", 138 | "\n", 139 | "のコマンドを入力し、実行して下さい。\n", 140 | "\n", 141 | "**3-B**: 上のガイドに従い「カーネル再起動」を行い、その後で``print(func(2, 1))``のセルを再度実行して下さい。\n", 142 | " \n", 143 | "**3-C**: グラフ描画のセルを実行した後でもう一度``print(func(2, 1))``を実行して下さい。 " 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "(解説)\n", 151 | "3-Aの段階でfunc(2, 1)が計算できたのは、グラフ描画を行うセルの中にこの関数の定義が含まれていたからです。 \n", 152 | "「カーネル再起動」を行うことで、この定義もクリアされました。それで3-Bの段階では同じ関数呼び出しがエラーになりました。" 153 | ] 154 | }, 155 | { 156 | "cell_type": "markdown", 157 | "metadata": {}, 158 | "source": [ 159 | "### 4番目の課題 (Notebookファイルの保存)\n", 160 | "\n", 161 | "今までの実行結果を外部ファイルとして保存し、保存結果を提出して下さい。" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "metadata": {}, 168 | "outputs": [], 169 | "source": [] 170 | } 171 | ], 172 | "metadata": { 173 | "kernelspec": { 174 | "display_name": "Python 3", 175 | "language": "python", 176 | "name": "python3" 177 | }, 178 | "language_info": { 179 | "codemirror_mode": { 180 | "name": "ipython", 181 | "version": 3 182 | }, 183 | "file_extension": ".py", 184 | "mimetype": "text/x-python", 185 | "name": "python", 186 | "nbconvert_exporter": "python", 187 | "pygments_lexer": "ipython3", 188 | "version": "3.7.3" 189 | } 190 | }, 191 | "nbformat": 4, 192 | "nbformat_minor": 1 193 | } 194 | -------------------------------------------------------------------------------- /notebooks/14-numpy2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Numpy入門2\n", 8 | "7章の単回帰モデル実習での、学習データ準備の過程を詳しく説明しました。 \n", 9 | "(この解説は書籍には含まれていません)" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "# 必要ライブラリimport\n", 19 | "import numpy as np\n", 20 | "from sklearn.datasets import load_boston" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "# 学習用データの読み込み\n", 30 | "# Boston Dataセットというよく使われるデータなので、関数を呼び出すと自動的にダウンロードされます\n", 31 | "\n", 32 | "boston = load_boston()\n", 33 | "x_org, yt = boston.data, boston.target\n", 34 | "feature_names = boston.feature_names" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 3, 40 | "metadata": {}, 41 | "outputs": [ 42 | { 43 | "name": "stdout", 44 | "output_type": "stream", 45 | "text": [ 46 | "[24. 21.6 34.7 33.4 36.2]\n" 47 | ] 48 | } 49 | ], 50 | "source": [ 51 | "# 正解データ ytの表示(一部)\n", 52 | "\n", 53 | "print(yt[:5])" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 4, 59 | "metadata": {}, 60 | "outputs": [ 61 | { 62 | "name": "stdout", 63 | "output_type": "stream", 64 | "text": [ 65 | "クラス名: \n", 66 | "サイズ: (506, 13)\n", 67 | "内容表示(一部):\n", 68 | "[[6.3200e-03 1.8000e+01 2.3100e+00 0.0000e+00 5.3800e-01 6.5750e+00\n", 69 | " 6.5200e+01 4.0900e+00 1.0000e+00 2.9600e+02 1.5300e+01 3.9690e+02\n", 70 | " 4.9800e+00]\n", 71 | " [2.7310e-02 0.0000e+00 7.0700e+00 0.0000e+00 4.6900e-01 6.4210e+00\n", 72 | " 7.8900e+01 4.9671e+00 2.0000e+00 2.4200e+02 1.7800e+01 3.9690e+02\n", 73 | " 9.1400e+00]\n", 74 | " [2.7290e-02 0.0000e+00 7.0700e+00 0.0000e+00 4.6900e-01 7.1850e+00\n", 75 | " 6.1100e+01 4.9671e+00 2.0000e+00 2.4200e+02 1.7800e+01 3.9283e+02\n", 76 | " 4.0300e+00]\n", 77 | " [3.2370e-02 0.0000e+00 2.1800e+00 0.0000e+00 4.5800e-01 6.9980e+00\n", 78 | " 4.5800e+01 6.0622e+00 3.0000e+00 2.2200e+02 1.8700e+01 3.9463e+02\n", 79 | " 2.9400e+00]\n", 80 | " [6.9050e-02 0.0000e+00 2.1800e+00 0.0000e+00 4.5800e-01 7.1470e+00\n", 81 | " 5.4200e+01 6.0622e+00 3.0000e+00 2.2200e+02 1.8700e+01 3.9690e+02\n", 82 | " 5.3300e+00]]\n", 83 | "項目名: ['CRIM' 'ZN' 'INDUS' 'CHAS' 'NOX' 'RM' 'AGE' 'DIS' 'RAD' 'TAX' 'PTRATIO'\n", 84 | " 'B' 'LSTAT']\n" 85 | ] 86 | } 87 | ], 88 | "source": [ 89 | "# x_orgの内容を調べる\n", 90 | "\n", 91 | "print('クラス名:', type(x_org))\n", 92 | "print('サイズ:', x_org.shape)\n", 93 | "print('内容表示(一部):')\n", 94 | "print( x_org[:5,:])\n", 95 | "print('項目名: ', feature_names)" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 5, 101 | "metadata": {}, 102 | "outputs": [], 103 | "source": [ 104 | "# x_org は506 x 13 の行列\n", 105 | "# この行列から'RM' の列だけを抽出する\n", 106 | "\n", 107 | "x_data = x_org[:,feature_names == 'RM']" 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": 6, 113 | "metadata": {}, 114 | "outputs": [ 115 | { 116 | "name": "stdout", 117 | "output_type": "stream", 118 | "text": [ 119 | "絞り込み後のサイズ (506, 1)\n", 120 | "絞り込み後の内容(一部)\n", 121 | "[[6.575]\n", 122 | " [6.421]\n", 123 | " [7.185]\n", 124 | " [6.998]\n", 125 | " [7.147]]\n" 126 | ] 127 | } 128 | ], 129 | "source": [ 130 | "# 結果確認\n", 131 | "\n", 132 | "print('絞り込み後のサイズ', x_data.shape)\n", 133 | "print('絞り込み後の内容(一部)')\n", 134 | "print( x_data[:5])" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 7, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "# ダミー変数を追加\n", 144 | "\n", 145 | "x = np.insert(x_data, 0, 1.0, axis=1)" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": 8, 151 | "metadata": {}, 152 | "outputs": [ 153 | { 154 | "name": "stdout", 155 | "output_type": "stream", 156 | "text": [ 157 | "ダミー変数追加後のサイズ (506, 2)\n", 158 | "ダミー変数追加後の内容(一部):\n", 159 | "[[1. 6.575]\n", 160 | " [1. 6.421]\n", 161 | " [1. 7.185]\n", 162 | " [1. 6.998]\n", 163 | " [1. 7.147]]\n" 164 | ] 165 | } 166 | ], 167 | "source": [ 168 | "# 結果確認\n", 169 | "\n", 170 | "print('ダミー変数追加後のサイズ', x.shape)\n", 171 | "print('ダミー変数追加後の内容(一部):')\n", 172 | "print( x[:5,:])" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "## 重回帰用データ追加" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 9, 185 | "metadata": {}, 186 | "outputs": [], 187 | "source": [ 188 | "# 列(LSTAT: 低所得者率)の取得\n", 189 | "x_add = x_org[:,feature_names == 'LSTAT']" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": 10, 195 | "metadata": {}, 196 | "outputs": [ 197 | { 198 | "name": "stdout", 199 | "output_type": "stream", 200 | "text": [ 201 | "絞り込み後のサイズ (506, 1)\n", 202 | "絞り込み後の内容(一部)\n", 203 | "[[4.98]\n", 204 | " [9.14]\n", 205 | " [4.03]\n", 206 | " [2.94]\n", 207 | " [5.33]]\n" 208 | ] 209 | } 210 | ], 211 | "source": [ 212 | "# 結果確認\n", 213 | "print('絞り込み後のサイズ', x_add.shape)\n", 214 | "print('絞り込み後の内容(一部)')\n", 215 | "print( x_add[:5])" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": 11, 221 | "metadata": {}, 222 | "outputs": [], 223 | "source": [ 224 | "# xに列を追加\n", 225 | "x2 = np.hstack((x, x_add))" 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": 12, 231 | "metadata": {}, 232 | "outputs": [ 233 | { 234 | "name": "stdout", 235 | "output_type": "stream", 236 | "text": [ 237 | "絞り込み後のサイズ (506, 3)\n", 238 | "絞り込み後の内容(一部)\n", 239 | "[[1. 6.575 4.98 ]\n", 240 | " [1. 6.421 9.14 ]\n", 241 | " [1. 7.185 4.03 ]\n", 242 | " [1. 6.998 2.94 ]\n", 243 | " [1. 7.147 5.33 ]]\n" 244 | ] 245 | } 246 | ], 247 | "source": [ 248 | "# 結果確認\n", 249 | "print('絞り込み後のサイズ', x2.shape)\n", 250 | "print('絞り込み後の内容(一部)')\n", 251 | "print( x2[:5])" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": {}, 258 | "outputs": [], 259 | "source": [] 260 | } 261 | ], 262 | "metadata": { 263 | "kernelspec": { 264 | "display_name": "Python 3", 265 | "language": "python", 266 | "name": "python3" 267 | }, 268 | "language_info": { 269 | "codemirror_mode": { 270 | "name": "ipython", 271 | "version": 3 272 | }, 273 | "file_extension": ".py", 274 | "mimetype": "text/x-python", 275 | "name": "python", 276 | "nbconvert_exporter": "python", 277 | "pygments_lexer": "ipython3", 278 | "version": "3.7.3" 279 | } 280 | }, 281 | "nbformat": 4, 282 | "nbformat_minor": 2 283 | } 284 | -------------------------------------------------------------------------------- /notebooks/12-python2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Python基本文法2\n", 8 | "文字列から関数定義まで" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "metadata": {}, 14 | "source": [ 15 | "### 文字列\n", 16 | "\n", 17 | "文字列はstrという型を持っていますが、文字の配列としての性質も持っています。" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": null, 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "str1 = 'Hello World!'" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "# クラス名が表示される (文字列クラスとしての振る舞い)\n", 36 | "\n", 37 | "print(type(str1))" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [ 46 | "# 文字数が表示される (配列としての振る舞い)\n", 47 | "\n", 48 | "print(len(str1))" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [ 57 | "# 最初の文字が表示される (配列としての振る舞い)\n", 58 | "\n", 59 | "print(str1[0])" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": null, 65 | "metadata": {}, 66 | "outputs": [], 67 | "source": [ 68 | "# 0以上5未満の要素が表示 (配列としての振る舞い)\n", 69 | "\n", 70 | "print(str1[0:5])" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": {}, 76 | "source": [ 77 | "#### print関数の利用\n", 78 | "\n", 79 | " print関数で、文字列と数値をつないで表示したい場合、複数のパラメータを列挙する形にします。" 80 | ] 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": null, 85 | "metadata": {}, 86 | "outputs": [], 87 | "source": [ 88 | "# 整数変数\n", 89 | "\n", 90 | "x1 = 1\n", 91 | "\n", 92 | "# 浮動小数点変数\n", 93 | "\n", 94 | "x2 = 2.0\n", 95 | "\n", 96 | "# 整数の表示\n", 97 | "print('x1 = ', x1, ' x2 = ', x2)" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": {}, 104 | "outputs": [], 105 | "source": [ 106 | "# print文実行の別方法\n", 107 | "# (書式つき文字列)\n", 108 | "\n", 109 | "print('x1 = %d x2 = %3.1f' % (x1, x2))" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "### range関数\n", 117 | "\n", 118 | "``range``関数を使うと、数値を要素をとしてもつリストを一気に作ることができます。 \n", 119 | "Python3では、そのままprint関数にかけると``range``オブジェクトとして表示されてしまうので、 \n", 120 | "``print``関数でその内容を見たい場合は、その結果を``list``関数にかけます。" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": null, 126 | "metadata": {}, 127 | "outputs": [], 128 | "source": [ 129 | "# 1引数の例 (0から10未満まで)\n", 130 | "\n", 131 | "print(range(10))\n", 132 | "print(list(range(10)))" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": null, 138 | "metadata": {}, 139 | "outputs": [], 140 | "source": [ 141 | "# 2引数の例 (2から10未満まで)\n", 142 | "\n", 143 | "print(list(range(2, 10)))" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": null, 149 | "metadata": {}, 150 | "outputs": [], 151 | "source": [ 152 | "# 3引数の例 (1から11未満まで2刻み)\n", 153 | "\n", 154 | "print(list(range(1, 11, 2)))" 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "### 辞書(key-value)\n", 162 | "\n", 163 | "辞書型のデータも扱うことができます。 \n", 164 | "辞書は``dict['key1']``のような形で参照します。 \n", 165 | "他のプログラム言語でハッシュ型とか連想配列を呼ばれる型になります。" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": null, 171 | "metadata": {}, 172 | "outputs": [], 173 | "source": [ 174 | "# 辞書型の宣言\n", 175 | "\n", 176 | "dict = {\n", 177 | " 'key1': 1,\n", 178 | " 'key2': 2.0,\n", 179 | " 'key3': 'abc'\n", 180 | "}" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": null, 186 | "metadata": {}, 187 | "outputs": [], 188 | "source": [ 189 | "# キーから値の取得\n", 190 | "\n", 191 | "print(dict['key1'])\n", 192 | "print(dict['key2'])\n", 193 | "print(dict['key3'])" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": null, 199 | "metadata": {}, 200 | "outputs": [], 201 | "source": [ 202 | "# キーの一覧表示\n", 203 | "\n", 204 | "keys = dict.keys()\n", 205 | "print(keys)" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": null, 211 | "metadata": {}, 212 | "outputs": [], 213 | "source": [ 214 | "# ソートしたい場合\n", 215 | "print(sorted(keys))" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": null, 221 | "metadata": {}, 222 | "outputs": [], 223 | "source": [ 224 | "# 値の一覧表示\n", 225 | "\n", 226 | "values = dict.values()\n", 227 | "print(values)" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "#### items関数\n", 235 | "\n", 236 | "辞書型データに対しては、``keys()``や``values()``という関数以外に``items()``という関数があり、 \n", 237 | "``(key, value)``のペアをリストにして取得できます。 \n", 238 | "この関数は、後で説明するループ処理の時に便利な関数です。" 239 | ] 240 | }, 241 | { 242 | "cell_type": "code", 243 | "execution_count": null, 244 | "metadata": {}, 245 | "outputs": [], 246 | "source": [ 247 | "print(dict)\n", 248 | "print(dict.items())" 249 | ] 250 | }, 251 | { 252 | "cell_type": "markdown", 253 | "metadata": {}, 254 | "source": [ 255 | "### 分岐\n", 256 | "\n", 257 | "Pythonの他の言語との大きな違いの一つとしては分岐、ループなどの制御構造の書き方があります。 \n", 258 | "制御構造の始まりの行は:で終わります。 \n", 259 | "また、制御構造の内部はインデント(字下げ)で表現します。\n", 260 | "(インデントの時はタブキーを入力) \n", 261 | "字下げが文法的に意味があるということです。 \n", 262 | "こうすることで、制御構造の戻りの記述が不要になり、プログラムが見やすくなっています。" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": null, 268 | "metadata": {}, 269 | "outputs": [], 270 | "source": [ 271 | "list4 = [0, 1, 2, 3]\n", 272 | "if list4[0] == 0:\n", 273 | " print('true branch')\n", 274 | "else:\n", 275 | " print('false branch')\n", 276 | "\n", 277 | "list4[0] = 1\n", 278 | "if list4[0] == 0:\n", 279 | " print('true branch')\n", 280 | "else:\n", 281 | " print('false branch')" 282 | ] 283 | }, 284 | { 285 | "cell_type": "markdown", 286 | "metadata": {}, 287 | "source": [ 288 | "### ループ\n", 289 | "\n", 290 | "ループも分岐同様、始まりが:でループ内部をインデントで表現します。 \n", 291 | "forループの場合、制御変数を使うことはあまりなく、 \n", 292 | "\n", 293 | "for (要素) in (List): \n", 294 | " (要素を使った処理) \n", 295 | "\n", 296 | "で組むことが多いです。\n" 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": null, 302 | "metadata": {}, 303 | "outputs": [], 304 | "source": [ 305 | "list5 = ['one', 'two', 'three']\n", 306 | "for item in list5:\n", 307 | " print(item)" 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": null, 313 | "metadata": {}, 314 | "outputs": [], 315 | "source": [ 316 | "# range関数とループを組み合わせた例\n", 317 | "for index in range(5):\n", 318 | " print(index)" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [ 327 | "# 辞書型データを対象にしたループ処理\n", 328 | "dict = {\n", 329 | " 'key1': 1,\n", 330 | " 'key2': 2.0,\n", 331 | " 'key3': 'abc'\n", 332 | "}\n", 333 | "\n", 334 | "# 辞書型変数dictに対してitems()関数で(key, value)をセットで取得します。\n", 335 | "\n", 336 | "for key, value in dict.items():\n", 337 | " print(key, ' = ', value)" 338 | ] 339 | }, 340 | { 341 | "cell_type": "markdown", 342 | "metadata": {}, 343 | "source": [ 344 | "#### リスト内包表記\n", 345 | "\n", 346 | "リスト内包表記はPython固有の表記法の一つです。 \n", 347 | "ループ処理を簡潔で直感的にわかりやすい表記で記述することができます。 \n", 348 | "機械学習のコーディングでよく出てくるので、是非使えるようにして下さい。" 349 | ] 350 | }, 351 | { 352 | "cell_type": "markdown", 353 | "metadata": {}, 354 | "source": [ 355 | "![](https://github.com/makaishi2/kcgi-course-contents/raw/master/images/python-fig1.png)" 356 | ] 357 | }, 358 | { 359 | "cell_type": "code", 360 | "execution_count": null, 361 | "metadata": {}, 362 | "outputs": [], 363 | "source": [ 364 | "list_str = ['abc', 'def', 'ghi']" 365 | ] 366 | }, 367 | { 368 | "cell_type": "code", 369 | "execution_count": null, 370 | "metadata": {}, 371 | "outputs": [], 372 | "source": [ 373 | "# 「リスト内包表記」の実装サンプル\n", 374 | "# 各要素の後ろに':'を追加\n", 375 | "\n", 376 | "ret3 = [item + ':' for item in list_str]\n", 377 | "print(ret3)" 378 | ] 379 | }, 380 | { 381 | "cell_type": "markdown", 382 | "metadata": {}, 383 | "source": [ 384 | "![](https://github.com/makaishi2/kcgi-course-contents/raw/master/images/python-fig2.png)" 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": null, 390 | "metadata": {}, 391 | "outputs": [], 392 | "source": [ 393 | "# 「リスト内包表記」をifと組みあわせた実装サンプル\n", 394 | "# 前の計算結果のうち、要素が'def'のものを除く\n", 395 | "\n", 396 | "ret4 = [item + ':' for item in list_str if item != 'def']\n", 397 | "print(ret4)" 398 | ] 399 | }, 400 | { 401 | "cell_type": "markdown", 402 | "metadata": {}, 403 | "source": [ 404 | "### enumerate関数\n", 405 | "\n", 406 | "``enumerate``関数を使うと、リストから``(index, element)``のペアを生成することができます。 \n", 407 | "この関数はループ処理で便利です。" 408 | ] 409 | }, 410 | { 411 | "cell_type": "code", 412 | "execution_count": null, 413 | "metadata": {}, 414 | "outputs": [], 415 | "source": [ 416 | "list5 = ['one', 'two', 'three']\n", 417 | "\n", 418 | "for index, item in enumerate(list5):\n", 419 | " print(index, ': ', item)" 420 | ] 421 | }, 422 | { 423 | "cell_type": "markdown", 424 | "metadata": {}, 425 | "source": [ 426 | "### 関数\n", 427 | "\n", 428 | "関数も分岐、ループ同様インデントで関数内部を表現します。\n" 429 | ] 430 | }, 431 | { 432 | "cell_type": "code", 433 | "execution_count": null, 434 | "metadata": {}, 435 | "outputs": [], 436 | "source": [ 437 | "# 関数定義の例\n", 438 | "\n", 439 | "def square(x) :\n", 440 | " return x * x" 441 | ] 442 | }, 443 | { 444 | "cell_type": "code", 445 | "execution_count": null, 446 | "metadata": {}, 447 | "outputs": [], 448 | "source": [ 449 | "# 関数呼出しの例\n", 450 | "\n", 451 | "print(square(3))" 452 | ] 453 | }, 454 | { 455 | "cell_type": "code", 456 | "execution_count": null, 457 | "metadata": {}, 458 | "outputs": [], 459 | "source": [ 460 | "# 無名関数(lambda式)を使った関数定義の例\n", 461 | "\n", 462 | "square2 = lambda x: x**2\n", 463 | "print(square2(3))" 464 | ] 465 | }, 466 | { 467 | "cell_type": "code", 468 | "execution_count": null, 469 | "metadata": {}, 470 | "outputs": [], 471 | "source": [ 472 | "# 複数の値を返す関数の例\n", 473 | "def powers(x):\n", 474 | " return x ** 2, x ** 3, x ** 4" 475 | ] 476 | }, 477 | { 478 | "cell_type": "code", 479 | "execution_count": null, 480 | "metadata": {}, 481 | "outputs": [], 482 | "source": [ 483 | "x2, x3, x4 = powers(5)\n", 484 | "print('x2 = ', x2)\n", 485 | "print('x3 = ', x3)\n", 486 | "print('x4 = ', x4)\n" 487 | ] 488 | }, 489 | { 490 | "cell_type": "code", 491 | "execution_count": null, 492 | "metadata": {}, 493 | "outputs": [], 494 | "source": [] 495 | } 496 | ], 497 | "metadata": { 498 | "kernelspec": { 499 | "display_name": "Python 3", 500 | "language": "python", 501 | "name": "python3" 502 | }, 503 | "language_info": { 504 | "codemirror_mode": { 505 | "name": "ipython", 506 | "version": 3 507 | }, 508 | "file_extension": ".py", 509 | "mimetype": "text/x-python", 510 | "name": "python", 511 | "nbconvert_exporter": "python", 512 | "pygments_lexer": "ipython3", 513 | "version": "3.7.3" 514 | } 515 | }, 516 | "nbformat": 4, 517 | "nbformat_minor": 1 518 | } 519 | -------------------------------------------------------------------------------- /notebooks/11-python1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Python基本文法1\n", 8 | "変数からタプルまで" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "metadata": {}, 14 | "source": [ 15 | "### 変数の型\n", 16 | "Pythonの変数には**整数型**、**浮動小数点型**、**文字列型**、**ブーリアン型**などがあります。 \n", 17 | "C言語のような型の宣言は不要で、代入された値から自動的に型の設定がされます。 \n", 18 | "変数がどの型を持っているかは、``type``関数で調べることができます。 \n", 19 | "また、変数の値そのものは ``print``関数で表示できます。" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 1, 25 | "metadata": {}, 26 | "outputs": [ 27 | { 28 | "name": "stdout", 29 | "output_type": "stream", 30 | "text": [ 31 | "2\n", 32 | "\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "# 整数型の例\n", 38 | "\n", 39 | "x1 = 2\n", 40 | "print(x1)\n", 41 | "print(type(x1))" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 2, 47 | "metadata": {}, 48 | "outputs": [ 49 | { 50 | "name": "stdout", 51 | "output_type": "stream", 52 | "text": [ 53 | "3.0\n", 54 | "\n" 55 | ] 56 | } 57 | ], 58 | "source": [ 59 | "# 浮動小数点型の例\n", 60 | "\n", 61 | "x2 = 3.0\n", 62 | "print(x2)\n", 63 | "print(type(x2))" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 3, 69 | "metadata": {}, 70 | "outputs": [ 71 | { 72 | "name": "stdout", 73 | "output_type": "stream", 74 | "text": [ 75 | "abc\n", 76 | "\n" 77 | ] 78 | } 79 | ], 80 | "source": [ 81 | "# 文字列型の例\n", 82 | "\n", 83 | "x3 = 'abc'\n", 84 | "print(x3)\n", 85 | "print(type(x3))" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 4, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "name": "stdout", 95 | "output_type": "stream", 96 | "text": [ 97 | "True\n", 98 | "\n" 99 | ] 100 | } 101 | ], 102 | "source": [ 103 | "# ブーリアン型(True/False)の例\n", 104 | "\n", 105 | "x4 = True\n", 106 | "print(x4)\n", 107 | "print(type(x4))" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "### 演算\n", 115 | "\n", 116 | "数値間の演算は他のプログラム言語同様 ``+, -, *, /`` 等を使います。 \n", 117 | "文字列同士の連結にも ``+`` を使います。" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": 5, 123 | "metadata": {}, 124 | "outputs": [ 125 | { 126 | "name": "stdout", 127 | "output_type": "stream", 128 | "text": [ 129 | "5 \n" 130 | ] 131 | } 132 | ], 133 | "source": [ 134 | "# 整数同士の和\n", 135 | "\n", 136 | "x1 = 2\n", 137 | "y1 = 3\n", 138 | "z1 = x1 + y1\n", 139 | "print(z1, type(z1))" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 6, 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "5.0 \n" 152 | ] 153 | } 154 | ], 155 | "source": [ 156 | "# 浮動小数点同士の和\n", 157 | "\n", 158 | "x2 = 3.0\n", 159 | "y2 = 2.0\n", 160 | "z2 = x2 + y2\n", 161 | "print(z2, type(z2)) " 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": 7, 167 | "metadata": {}, 168 | "outputs": [ 169 | { 170 | "name": "stdout", 171 | "output_type": "stream", 172 | "text": [ 173 | "abcXYZ \n" 174 | ] 175 | } 176 | ], 177 | "source": [ 178 | "# 文字列の連結\n", 179 | "\n", 180 | "x3 = 'abc'\n", 181 | "y3 = 'XYZ'\n", 182 | "z3 = x3 + y3\n", 183 | "print(z3, type(z3))" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 8, 189 | "metadata": {}, 190 | "outputs": [ 191 | { 192 | "name": "stdout", 193 | "output_type": "stream", 194 | "text": [ 195 | "4.0 \n" 196 | ] 197 | } 198 | ], 199 | "source": [ 200 | "# 整数と浮動小数点間の演算\n", 201 | "# 自動的に方が浮動小数点に合わせられる\n", 202 | "\n", 203 | "y4 = x1 + y2\n", 204 | "print(y4, type(y4))" 205 | ] 206 | }, 207 | { 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "#### 比較演算子\n", 212 | "比較演算子は ``==`` です。" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 9, 218 | "metadata": {}, 219 | "outputs": [ 220 | { 221 | "name": "stdout", 222 | "output_type": "stream", 223 | "text": [ 224 | "True\n", 225 | "False\n" 226 | ] 227 | } 228 | ], 229 | "source": [ 230 | "x1 = 2\n", 231 | "y1 = 3\n", 232 | "w1 = 2\n", 233 | "\n", 234 | "print(w1 == x1)\n", 235 | "print(w1 == y1)" 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "#### 論理演算子\n", 243 | "\n", 244 | "論理演算子は ``and``, ``or``, ``not``です。" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": 10, 250 | "metadata": {}, 251 | "outputs": [], 252 | "source": [ 253 | "t1 = True\n", 254 | "t2 = True\n", 255 | "f1 = False\n", 256 | "f2 = False" 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": 11, 262 | "metadata": {}, 263 | "outputs": [ 264 | { 265 | "name": "stdout", 266 | "output_type": "stream", 267 | "text": [ 268 | "True False\n" 269 | ] 270 | } 271 | ], 272 | "source": [ 273 | "# AND演算\n", 274 | "\n", 275 | "p1 = t1 and t2\n", 276 | "p2 = t1 and f2\n", 277 | "print(p1, p2)" 278 | ] 279 | }, 280 | { 281 | "cell_type": "code", 282 | "execution_count": 12, 283 | "metadata": {}, 284 | "outputs": [ 285 | { 286 | "name": "stdout", 287 | "output_type": "stream", 288 | "text": [ 289 | "True False\n" 290 | ] 291 | } 292 | ], 293 | "source": [ 294 | "# OR演算\n", 295 | "\n", 296 | "q1 = t1 or f1\n", 297 | "q2 = f1 or f2\n", 298 | "print(q1, q2)" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": 13, 304 | "metadata": {}, 305 | "outputs": [ 306 | { 307 | "name": "stdout", 308 | "output_type": "stream", 309 | "text": [ 310 | "False True\n" 311 | ] 312 | } 313 | ], 314 | "source": [ 315 | "# NOT演算\n", 316 | "\n", 317 | "r1 = not t1\n", 318 | "r2 = not f1\n", 319 | "print(r1, r2)" 320 | ] 321 | }, 322 | { 323 | "cell_type": "markdown", 324 | "metadata": {}, 325 | "source": [ 326 | "### リスト\n", 327 | "\n", 328 | "リストは``[x, y, ...]``のような形式で表現します。 \n", 329 | "第一要素は``list[0]``, 第二要素は``list[1]``で参照します。 \n", 330 | "リストの長さを知りたいときは``len``関数を使います。" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 14, 336 | "metadata": {}, 337 | "outputs": [], 338 | "source": [ 339 | "# リストの定義\n", 340 | "\n", 341 | "list1 = [2, 4, 6, 8, 10, 12, 14]" 342 | ] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": 15, 347 | "metadata": {}, 348 | "outputs": [ 349 | { 350 | "name": "stdout", 351 | "output_type": "stream", 352 | "text": [ 353 | "\n" 354 | ] 355 | } 356 | ], 357 | "source": [ 358 | "# 型は\"list\"\n", 359 | "\n", 360 | "print(type(list1))" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": 16, 366 | "metadata": {}, 367 | "outputs": [ 368 | { 369 | "name": "stdout", 370 | "output_type": "stream", 371 | "text": [ 372 | "[2, 4, 6, 8, 10, 12, 14]\n" 373 | ] 374 | } 375 | ], 376 | "source": [ 377 | "# print関数にかけると、全要素が表示される\n", 378 | "\n", 379 | "print(list1)" 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": 17, 385 | "metadata": {}, 386 | "outputs": [ 387 | { 388 | "name": "stdout", 389 | "output_type": "stream", 390 | "text": [ 391 | "2\n" 392 | ] 393 | } 394 | ], 395 | "source": [ 396 | "# 第一要素の表示\n", 397 | "\n", 398 | "print(list1[0])" 399 | ] 400 | }, 401 | { 402 | "cell_type": "code", 403 | "execution_count": 18, 404 | "metadata": {}, 405 | "outputs": [ 406 | { 407 | "name": "stdout", 408 | "output_type": "stream", 409 | "text": [ 410 | "4\n" 411 | ] 412 | } 413 | ], 414 | "source": [ 415 | "# 第二要素の表示\n", 416 | "\n", 417 | "print(list1[1])" 418 | ] 419 | }, 420 | { 421 | "cell_type": "code", 422 | "execution_count": 19, 423 | "metadata": {}, 424 | "outputs": [ 425 | { 426 | "name": "stdout", 427 | "output_type": "stream", 428 | "text": [ 429 | "7\n" 430 | ] 431 | } 432 | ], 433 | "source": [ 434 | "# リストの長さはlen関数で取得\n", 435 | "\n", 436 | "print(len(list1))" 437 | ] 438 | }, 439 | { 440 | "cell_type": "markdown", 441 | "metadata": {}, 442 | "source": [ 443 | "### 部分リスト\n", 444 | "\n", 445 | "``list[0:3]``のような形式の参照も可能で、 \n", 446 | "この式は第1要素から第3要素までを抜き出した部分リストとなります。 \n", 447 | "**「0以上で3より前」**という読み方をするとわかりやすいです。" 448 | ] 449 | }, 450 | { 451 | "cell_type": "code", 452 | "execution_count": 20, 453 | "metadata": {}, 454 | "outputs": [ 455 | { 456 | "name": "stdout", 457 | "output_type": "stream", 458 | "text": [ 459 | "[2, 4, 6]\n" 460 | ] 461 | } 462 | ], 463 | "source": [ 464 | "# list[0]から list[3]より前\n", 465 | "\n", 466 | "print(list1[0:3])" 467 | ] 468 | }, 469 | { 470 | "cell_type": "markdown", 471 | "metadata": {}, 472 | "source": [ 473 | "#### 部分リストの参照パターン\n", 474 | "\n", 475 | "``list``を元に部分リストを作る方法には、以下のようないろいろなバリエーションがあります。 \n", 476 | "機械学習のコーディングでよく使われるテクニックなので、是非マスターして下さい。" 477 | ] 478 | }, 479 | { 480 | "cell_type": "code", 481 | "execution_count": 21, 482 | "metadata": {}, 483 | "outputs": [ 484 | { 485 | "name": "stdout", 486 | "output_type": "stream", 487 | "text": [ 488 | "[2, 4]\n", 489 | "[2, 4]\n" 490 | ] 491 | } 492 | ], 493 | "source": [ 494 | "# 最初からlist[2]より前\n", 495 | "print(list1[0:2])\n", 496 | "\n", 497 | "# 第一引数を省略すると\"0\"であるとみなされる\n", 498 | "print(list1[:2])" 499 | ] 500 | }, 501 | { 502 | "cell_type": "code", 503 | "execution_count": 22, 504 | "metadata": {}, 505 | "outputs": [ 506 | { 507 | "name": "stdout", 508 | "output_type": "stream", 509 | "text": [ 510 | "[6, 8, 10, 12, 14]\n", 511 | "[6, 8, 10, 12, 14]\n" 512 | ] 513 | } 514 | ], 515 | "source": [ 516 | "# list[2]から最後まで\n", 517 | "\n", 518 | "len1 = len(list1)\n", 519 | "print(list1[2:len1])\n", 520 | "\n", 521 | "# 第二引数を省略すると最終要素(len(list)))であるとみなされる\n", 522 | "print(list1[2:])" 523 | ] 524 | }, 525 | { 526 | "cell_type": "code", 527 | "execution_count": 23, 528 | "metadata": {}, 529 | "outputs": [ 530 | { 531 | "name": "stdout", 532 | "output_type": "stream", 533 | "text": [ 534 | "[2, 4, 6, 8, 10, 12, 14]\n" 535 | ] 536 | } 537 | ], 538 | "source": [ 539 | "# ':'' だけの場合は、元のリスト全体を表す\n", 540 | "\n", 541 | "print(list1[:])" 542 | ] 543 | }, 544 | { 545 | "cell_type": "code", 546 | "execution_count": 24, 547 | "metadata": {}, 548 | "outputs": [ 549 | { 550 | "name": "stdout", 551 | "output_type": "stream", 552 | "text": [ 553 | "[12, 14]\n" 554 | ] 555 | } 556 | ], 557 | "source": [ 558 | "# 後ろから2つ\n", 559 | "\n", 560 | "print(list1[-2:])" 561 | ] 562 | }, 563 | { 564 | "cell_type": "code", 565 | "execution_count": 25, 566 | "metadata": {}, 567 | "outputs": [ 568 | { 569 | "name": "stdout", 570 | "output_type": "stream", 571 | "text": [ 572 | "[2, 4, 6, 8, 10]\n" 573 | ] 574 | } 575 | ], 576 | "source": [ 577 | "# 後ろの2つを取り除いたもの\n", 578 | "\n", 579 | "print(list1[:-2])" 580 | ] 581 | }, 582 | { 583 | "cell_type": "code", 584 | "execution_count": 26, 585 | "metadata": {}, 586 | "outputs": [ 587 | { 588 | "name": "stdout", 589 | "output_type": "stream", 590 | "text": [ 591 | "[2, 6, 10, 14]\n" 592 | ] 593 | } 594 | ], 595 | "source": [ 596 | "# 普段は使わないのですが、listには3つめの引数もあり、これを使うとこんなことも可能です\n", 597 | "\n", 598 | "# 一つおき\n", 599 | "\n", 600 | "print(list1[::2])" 601 | ] 602 | }, 603 | { 604 | "cell_type": "code", 605 | "execution_count": 27, 606 | "metadata": {}, 607 | "outputs": [ 608 | { 609 | "name": "stdout", 610 | "output_type": "stream", 611 | "text": [ 612 | "[14, 12, 10, 8, 6, 4, 2]\n" 613 | ] 614 | } 615 | ], 616 | "source": [ 617 | "# 第三引数に-1を指定すると「逆順」を意味します\n", 618 | "\n", 619 | "print(list1[::-1])" 620 | ] 621 | }, 622 | { 623 | "cell_type": "markdown", 624 | "metadata": {}, 625 | "source": [ 626 | "#### 異なる要素の混在\n", 627 | "\n", 628 | "リストの各要素は異なる型の混在もできます。" 629 | ] 630 | }, 631 | { 632 | "cell_type": "code", 633 | "execution_count": 28, 634 | "metadata": {}, 635 | "outputs": [ 636 | { 637 | "name": "stdout", 638 | "output_type": "stream", 639 | "text": [ 640 | "[1, 2.0, 'abc', False]\n" 641 | ] 642 | } 643 | ], 644 | "source": [ 645 | "list2 = [1, 2.0, 'abc', False]\n", 646 | "print(list2)" 647 | ] 648 | }, 649 | { 650 | "cell_type": "markdown", 651 | "metadata": {}, 652 | "source": [ 653 | "#### リストに要素の追加\n", 654 | "\n", 655 | "リストに要素を追加したい場合は、``append``関数を使います。" 656 | ] 657 | }, 658 | { 659 | "cell_type": "code", 660 | "execution_count": 29, 661 | "metadata": {}, 662 | "outputs": [ 663 | { 664 | "name": "stdout", 665 | "output_type": "stream", 666 | "text": [ 667 | "[1, 2.0, 'abc']\n" 668 | ] 669 | } 670 | ], 671 | "source": [ 672 | "# 空リストの定義\n", 673 | "list3 = []\n", 674 | "\n", 675 | "# 要素の追加\n", 676 | "list3.append(1)\n", 677 | "list3.append(2.0)\n", 678 | "list3.append('abc')\n", 679 | "print(list3)" 680 | ] 681 | }, 682 | { 683 | "cell_type": "markdown", 684 | "metadata": {}, 685 | "source": [ 686 | "#### リスト間の連結\n", 687 | "\n", 688 | "リストとリストを連結したい場合は、``+``演算子を使います。" 689 | ] 690 | }, 691 | { 692 | "cell_type": "code", 693 | "execution_count": 30, 694 | "metadata": {}, 695 | "outputs": [ 696 | { 697 | "name": "stdout", 698 | "output_type": "stream", 699 | "text": [ 700 | "[1, 2.0, 'abc', False, 1, 2.0, 'abc']\n" 701 | ] 702 | } 703 | ], 704 | "source": [ 705 | "list4 = list2 + list3\n", 706 | "print(list4)" 707 | ] 708 | }, 709 | { 710 | "cell_type": "markdown", 711 | "metadata": {}, 712 | "source": [ 713 | "### タプル\n", 714 | "\n", 715 | "リストと似たデータ型として「タプル」があります。 \n", 716 | "タプルは、値の変更不可能なリストであると考えて下さい。" 717 | ] 718 | }, 719 | { 720 | "cell_type": "code", 721 | "execution_count": 34, 722 | "metadata": {}, 723 | "outputs": [ 724 | { 725 | "name": "stdout", 726 | "output_type": "stream", 727 | "text": [ 728 | "(1, 3, 5, 7)\n", 729 | "\n" 730 | ] 731 | } 732 | ], 733 | "source": [ 734 | "# タプルの場合は[]でなく()で要素を囲みます\n", 735 | "\n", 736 | "tap1 = (1,3,5,7)\n", 737 | "print(tap1)\n", 738 | "print(type(tap1))" 739 | ] 740 | }, 741 | { 742 | "cell_type": "code", 743 | "execution_count": 35, 744 | "metadata": {}, 745 | "outputs": [ 746 | { 747 | "name": "stdout", 748 | "output_type": "stream", 749 | "text": [ 750 | "1 3\n" 751 | ] 752 | } 753 | ], 754 | "source": [ 755 | "# タプルの要素への参照はリスト同様[]で行います\n", 756 | "print(tap1[0], tap1[1])" 757 | ] 758 | }, 759 | { 760 | "cell_type": "code", 761 | "execution_count": 36, 762 | "metadata": {}, 763 | "outputs": [ 764 | { 765 | "ename": "TypeError", 766 | "evalue": "'tuple' object does not support item assignment", 767 | "output_type": "error", 768 | "traceback": [ 769 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 770 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", 771 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# 値を変更しようとすると 。。。\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtap1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 772 | "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" 773 | ] 774 | } 775 | ], 776 | "source": [ 777 | "# 値を変更しようとすると 。。。\n", 778 | "tap1[1] = 10" 779 | ] 780 | }, 781 | { 782 | "cell_type": "code", 783 | "execution_count": 37, 784 | "metadata": {}, 785 | "outputs": [ 786 | { 787 | "name": "stdout", 788 | "output_type": "stream", 789 | "text": [ 790 | "[2, 4, 9, 8, 10]\n" 791 | ] 792 | } 793 | ], 794 | "source": [ 795 | "# リストの場合、上のこと(要素を後で変更する)は可能です\n", 796 | "\n", 797 | "list7 = [2,4,6,8,10]\n", 798 | "list7[2] = 9\n", 799 | "print(list7)" 800 | ] 801 | } 802 | ], 803 | "metadata": { 804 | "kernelspec": { 805 | "display_name": "Python 3", 806 | "language": "python", 807 | "name": "python3" 808 | }, 809 | "language_info": { 810 | "codemirror_mode": { 811 | "name": "ipython", 812 | "version": 3 813 | }, 814 | "file_extension": ".py", 815 | "mimetype": "text/x-python", 816 | "name": "python", 817 | "nbconvert_exporter": "python", 818 | "pygments_lexer": "ipython3", 819 | "version": "3.7.3" 820 | } 821 | }, 822 | "nbformat": 4, 823 | "nbformat_minor": 1 824 | } 825 | -------------------------------------------------------------------------------- /notebooks/13-numpy1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Numpy入門1" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "### Numpyの特徴\n", 15 | "\n", 16 | "numpy配列を使って、配列計算を行えます。 \n", 17 | "NativeなPythonの機能と比較してNumpyを使うことにより次のメリットがあります。\n", 18 | "\n", 19 | "* 処理速度が早くなる\n", 20 | "* 配列の扱い方が柔軟\n", 21 | "* コードがシンプルになる\n", 22 | "\n", 23 | "より詳しい解説は例えば下記のリンク参照して下さい。 \n", 24 | "[numpyの何がすごいのか？](https://to-kei.net/python/data-analysis/what-is-numpy/)\n" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "### 一次元配列" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "#### 宣言" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 1, 44 | "metadata": {}, 45 | "outputs": [], 46 | "source": [ 47 | "# ライブラリのロード\n", 48 | "import numpy as np\n", 49 | "\n", 50 | "# 一次元配列の作成\n", 51 | "# リスト配列を引数に、array関数でnumpy一次元配列を作ります。\n", 52 | "\n", 53 | "list1 = list(range(2,12,2))\n", 54 | "array1 = np.array(list1)" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 2, 60 | "metadata": {}, 61 | "outputs": [ 62 | { 63 | "name": "stdout", 64 | "output_type": "stream", 65 | "text": [ 66 | "list配列: [2, 4, 6, 8, 10]\n", 67 | "numpy配列: [ 2 4 6 8 10]\n" 68 | ] 69 | }, 70 | { 71 | "data": { 72 | "text/plain": [ 73 | "array([ 2, 4, 6, 8, 10])" 74 | ] 75 | }, 76 | "execution_count": 2, 77 | "metadata": {}, 78 | "output_type": "execute_result" 79 | } 80 | ], 81 | "source": [ 82 | "# print文による表示結果の比較\n", 83 | "# 画面上はカンマのあるなしで区別します。\n", 84 | "\n", 85 | "print('list配列: ', list1)\n", 86 | "print('numpy配列: ', array1)\n", 87 | "array1" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 3, 93 | "metadata": {}, 94 | "outputs": [ 95 | { 96 | "name": "stdout", 97 | "output_type": "stream", 98 | "text": [ 99 | "[ 2 4 6 8 10]\n" 100 | ] 101 | }, 102 | { 103 | "data": { 104 | "text/plain": [ 105 | "array([ 2, 4, 6, 8, 10], dtype=int32)" 106 | ] 107 | }, 108 | "execution_count": 3, 109 | "metadata": {}, 110 | "output_type": "execute_result" 111 | } 112 | ], 113 | "source": [ 114 | "# データ型(dtype)つき変数作成\n", 115 | "\n", 116 | "# 個々の要素をデータ型付きで定義することも可能です。\n", 117 | "# 型には、以下のようなものがあります。\n", 118 | "#\n", 119 | "# 符号付き整数: int8, int16, int32, int64\n", 120 | "# 符号なし整数: unit8, uint16, uint32, uint64\n", 121 | "# 浮動小数点: float16, float32, float64, float128\n", 122 | "\n", 123 | "array2 = np.array([2, 4, 6, 8,10], dtype=np.int32)\n", 124 | "print(array2)\n", 125 | "\n", 126 | "array2" 127 | ] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": 4, 132 | "metadata": {}, 133 | "outputs": [ 134 | { 135 | "name": "stdout", 136 | "output_type": "stream", 137 | "text": [ 138 | "\n" 139 | ] 140 | } 141 | ], 142 | "source": [ 143 | "# 型は' numpy.ndarray' となります\n", 144 | "\n", 145 | "print(type(array1))" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": 5, 151 | "metadata": {}, 152 | "outputs": [ 153 | { 154 | "name": "stdout", 155 | "output_type": "stream", 156 | "text": [ 157 | "(5,)\n" 158 | ] 159 | } 160 | ], 161 | "source": [ 162 | "# 配列の要素数は'shape'という属性で取得可能です\n", 163 | "# 結果はtuppleで返されます\n", 164 | "\n", 165 | "print(array1.shape)" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "#### 参照" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 6, 178 | "metadata": {}, 179 | "outputs": [ 180 | { 181 | "name": "stdout", 182 | "output_type": "stream", 183 | "text": [ 184 | "2\n", 185 | "10\n" 186 | ] 187 | } 188 | ], 189 | "source": [ 190 | "# 要素の参照例\n", 191 | "\n", 192 | "# 先頭\n", 193 | "print(array1[0])\n", 194 | "\n", 195 | "# 一番後ろの要素は-1で参照できます\n", 196 | "print(array1[-1])" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": 7, 202 | "metadata": {}, 203 | "outputs": [ 204 | { 205 | "name": "stdout", 206 | "output_type": "stream", 207 | "text": [ 208 | "[2 4]\n", 209 | "[ 6 8 10]\n", 210 | "[ 2 4 6 8 10]\n" 211 | ] 212 | } 213 | ], 214 | "source": [ 215 | "# 範囲付き参照\n", 216 | "# このパターンはlist変数と同じです。\n", 217 | "\n", 218 | "# 0以上2未満\n", 219 | "print(array1[:2])\n", 220 | "\n", 221 | "# 2以上\n", 222 | "print(array1[2:])\n", 223 | "\n", 224 | "# 全部\n", 225 | "print(array1[:])" 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": 8, 231 | "metadata": {}, 232 | "outputs": [ 233 | { 234 | "name": "stdout", 235 | "output_type": "stream", 236 | "text": [ 237 | "[ 2 6 10]\n", 238 | "[8 4]\n" 239 | ] 240 | } 241 | ], 242 | "source": [ 243 | "# こういうアクセス方法も可能です\n", 244 | "# (これはlistではできない)\n", 245 | "\n", 246 | "# array1の0番目、2番目、4番目\n", 247 | "print(array1[[0,2,4]])\n", 248 | "\n", 249 | "# array1の3番目、1番目\n", 250 | "print(array1[[3,1]])" 251 | ] 252 | }, 253 | { 254 | "cell_type": "markdown", 255 | "metadata": {}, 256 | "source": [ 257 | "#### 計算" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": 9, 263 | "metadata": {}, 264 | "outputs": [ 265 | { 266 | "name": "stdout", 267 | "output_type": "stream", 268 | "text": [ 269 | "[ 2 4 6 8 10]\n", 270 | "[0 1 2 3 4]\n" 271 | ] 272 | } 273 | ], 274 | "source": [ 275 | "# 計算の例\n", 276 | "# numpy配列を対象にすると計算を一気に行うことができます\n", 277 | "\n", 278 | "array1 = np.array(list(range(2,12,2)))\n", 279 | "array3 = np.array(list(range(5)))\n", 280 | "print(array1)\n", 281 | "print(array3)" 282 | ] 283 | }, 284 | { 285 | "cell_type": "code", 286 | "execution_count": 10, 287 | "metadata": {}, 288 | "outputs": [ 289 | { 290 | "name": "stdout", 291 | "output_type": "stream", 292 | "text": [ 293 | "[ 2 5 8 11 14]\n" 294 | ] 295 | } 296 | ], 297 | "source": [ 298 | "# 足し算\n", 299 | "# list変数だとループを回す必要があります\n", 300 | "\n", 301 | "array4 = array1 + array3\n", 302 | "print(array4)" 303 | ] 304 | }, 305 | { 306 | "cell_type": "markdown", 307 | "metadata": {}, 308 | "source": [ 309 | "#### ブロードキャスト機能" 310 | ] 311 | }, 312 | { 313 | "cell_type": "code", 314 | "execution_count": 11, 315 | "metadata": {}, 316 | "outputs": [ 317 | { 318 | "name": "stdout", 319 | "output_type": "stream", 320 | "text": [ 321 | "[ 5 7 9 11 13]\n" 322 | ] 323 | } 324 | ], 325 | "source": [ 326 | "# ブロードキャスト機能\n", 327 | "# サイズの異なる変数同士の演算では、サイズを自動的に合わせて計算します\n", 328 | "\n", 329 | "array5 = array1 + 3\n", 330 | "print(array5)" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 12, 336 | "metadata": {}, 337 | "outputs": [ 338 | { 339 | "name": "stdout", 340 | "output_type": "stream", 341 | "text": [ 342 | "[0.69314718 1.38629436 1.79175947 2.07944154 2.30258509]\n" 343 | ] 344 | } 345 | ], 346 | "source": [ 347 | "# 関数呼び出し\n", 348 | "# numpy関数と組み合わせると、関数呼び出しも全要素分まとめて行えます\n", 349 | "\n", 350 | "# 対数関数の呼出し\n", 351 | "array6 = np.log(array1)\n", 352 | "print(array6)" 353 | ] 354 | }, 355 | { 356 | "cell_type": "markdown", 357 | "metadata": {}, 358 | "source": [ 359 | "#### 特定の条件を満たす要素の抽出" 360 | ] 361 | }, 362 | { 363 | "cell_type": "code", 364 | "execution_count": 13, 365 | "metadata": {}, 366 | "outputs": [ 367 | { 368 | "name": "stdout", 369 | "output_type": "stream", 370 | "text": [ 371 | "[ True False True False True]\n" 372 | ] 373 | } 374 | ], 375 | "source": [ 376 | "# ブロードキャスト機能とindex機能を組み合わせてこんなことも可能です\n", 377 | "# arr2 から偶数の要素だけを抜き出す\n", 378 | "\n", 379 | "array3 = np.array(list(range(5)))\n", 380 | "w = (array3 % 2) == 0\n", 381 | "print(w)" 382 | ] 383 | }, 384 | { 385 | "cell_type": "code", 386 | "execution_count": 14, 387 | "metadata": {}, 388 | "outputs": [ 389 | { 390 | "name": "stdout", 391 | "output_type": "stream", 392 | "text": [ 393 | "[0 2 4]\n" 394 | ] 395 | } 396 | ], 397 | "source": [ 398 | "array7 = array3[w]\n", 399 | "print(array7)" 400 | ] 401 | }, 402 | { 403 | "cell_type": "code", 404 | "execution_count": 15, 405 | "metadata": {}, 406 | "outputs": [ 407 | { 408 | "name": "stdout", 409 | "output_type": "stream", 410 | "text": [ 411 | "[0 2 4]\n" 412 | ] 413 | } 414 | ], 415 | "source": [ 416 | "# まとめて書くとこうなります\n", 417 | "\n", 418 | "array8 = array3[(array3 % 2) == 0]\n", 419 | "print(array8)" 420 | ] 421 | }, 422 | { 423 | "cell_type": "markdown", 424 | "metadata": {}, 425 | "source": [ 426 | "#### 内積" 427 | ] 428 | }, 429 | { 430 | "cell_type": "code", 431 | "execution_count": 16, 432 | "metadata": {}, 433 | "outputs": [ 434 | { 435 | "name": "stdout", 436 | "output_type": "stream", 437 | "text": [ 438 | "[ 2 4 6 8 10]\n", 439 | "[0 1 2 3 4]\n", 440 | "80\n" 441 | ] 442 | } 443 | ], 444 | "source": [ 445 | "# 内積\n", 446 | "# 記号 '@' を使って内積計算が可能です。\n", 447 | "\n", 448 | "array1 = np.array(list(range(2,12,2)))\n", 449 | "array3 = np.array(list(range(5)))\n", 450 | "print(array1)\n", 451 | "print(array3)\n", 452 | "\n", 453 | "p = array1 @ array3\n", 454 | "print(p)" 455 | ] 456 | }, 457 | { 458 | "cell_type": "markdown", 459 | "metadata": {}, 460 | "source": [ 461 | "### 二次元配列\n", 462 | "\n", 463 | "numpyでは行列のような二次元配列も扱えます。 " 464 | ] 465 | }, 466 | { 467 | "cell_type": "markdown", 468 | "metadata": {}, 469 | "source": [ 470 | "#### 宣言" 471 | ] 472 | }, 473 | { 474 | "cell_type": "code", 475 | "execution_count": 17, 476 | "metadata": {}, 477 | "outputs": [], 478 | "source": [ 479 | "# 二次元配列の宣言\n", 480 | "# この場合、引数はlistのlistとなります。\n", 481 | "\n", 482 | "array8 = np.array([[1,2,3,4,5], [6,7,8,9,10],[11,12,13,14,15]])" 483 | ] 484 | }, 485 | { 486 | "cell_type": "code", 487 | "execution_count": 18, 488 | "metadata": {}, 489 | "outputs": [ 490 | { 491 | "name": "stdout", 492 | "output_type": "stream", 493 | "text": [ 494 | "[[ 1 2 3 4 5]\n", 495 | " [ 6 7 8 9 10]\n", 496 | " [11 12 13 14 15]]\n" 497 | ] 498 | } 499 | ], 500 | "source": [ 501 | "# 二次元配列をprint関数にかけるとこのような表示になります\n", 502 | "\n", 503 | "print(array8)" 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": 19, 509 | "metadata": {}, 510 | "outputs": [ 511 | { 512 | "name": "stdout", 513 | "output_type": "stream", 514 | "text": [ 515 | "(3, 5)\n" 516 | ] 517 | } 518 | ], 519 | "source": [ 520 | "# 要素数の取得\n", 521 | "\n", 522 | "print(array8.shape)" 523 | ] 524 | }, 525 | { 526 | "cell_type": "markdown", 527 | "metadata": {}, 528 | "source": [ 529 | "#### 参照" 530 | ] 531 | }, 532 | { 533 | "cell_type": "code", 534 | "execution_count": 20, 535 | "metadata": {}, 536 | "outputs": [ 537 | { 538 | "name": "stdout", 539 | "output_type": "stream", 540 | "text": [ 541 | "8\n" 542 | ] 543 | } 544 | ], 545 | "source": [ 546 | "# 要素の参照は「(第一次元引数),(第二次元引数)」の形式\n", 547 | "\n", 548 | "print(array8[1,2])" 549 | ] 550 | }, 551 | { 552 | "cell_type": "code", 553 | "execution_count": 21, 554 | "metadata": {}, 555 | "outputs": [ 556 | { 557 | "name": "stdout", 558 | "output_type": "stream", 559 | "text": [ 560 | "[[ 3 4 5]\n", 561 | " [ 8 9 10]]\n" 562 | ] 563 | } 564 | ], 565 | "source": [ 566 | "# それぞれの次元に対して範囲指定で参照することも可能\n", 567 | "\n", 568 | "print(array8[:2,2:])" 569 | ] 570 | }, 571 | { 572 | "cell_type": "markdown", 573 | "metadata": {}, 574 | "source": [ 575 | "#### 計算" 576 | ] 577 | }, 578 | { 579 | "cell_type": "code", 580 | "execution_count": 22, 581 | "metadata": {}, 582 | "outputs": [ 583 | { 584 | "name": "stdout", 585 | "output_type": "stream", 586 | "text": [ 587 | "[[ 3 6 9]\n", 588 | " [12 15 18]]\n" 589 | ] 590 | } 591 | ], 592 | "source": [ 593 | "# スカラー積\n", 594 | "\n", 595 | "a = np.array([[1,2,3],[4,5,6]])\n", 596 | "b = a * 3\n", 597 | "print(b)" 598 | ] 599 | }, 600 | { 601 | "cell_type": "code", 602 | "execution_count": 23, 603 | "metadata": {}, 604 | "outputs": [ 605 | { 606 | "name": "stdout", 607 | "output_type": "stream", 608 | "text": [ 609 | "[[4 5 6]\n", 610 | " [7 8 9]]\n" 611 | ] 612 | } 613 | ], 614 | "source": [ 615 | "# スカラー和\n", 616 | "\n", 617 | "a = np.array([[1,2,3],[4,5,6]])\n", 618 | "c = a + 3\n", 619 | "print(c)" 620 | ] 621 | }, 622 | { 623 | "cell_type": "code", 624 | "execution_count": 24, 625 | "metadata": {}, 626 | "outputs": [ 627 | { 628 | "name": "stdout", 629 | "output_type": "stream", 630 | "text": [ 631 | "[[ 4 8 12]\n", 632 | " [16 20 24]]\n" 633 | ] 634 | } 635 | ], 636 | "source": [ 637 | "# 行列同士の和\n", 638 | "\n", 639 | "d = a + b\n", 640 | "print(d)" 641 | ] 642 | }, 643 | { 644 | "cell_type": "code", 645 | "execution_count": 25, 646 | "metadata": {}, 647 | "outputs": [ 648 | { 649 | "name": "stdout", 650 | "output_type": "stream", 651 | "text": [ 652 | "[[1 2 3]\n", 653 | " [4 5 6]]\n", 654 | "[3 2 1]\n" 655 | ] 656 | } 657 | ], 658 | "source": [ 659 | "# 行列と1次元配列の内積\n", 660 | "\n", 661 | "a = np.array([[1,2,3],[4,5,6]])\n", 662 | "x = np.array([3,2,1])\n", 663 | "print(a)\n", 664 | "print(x)" 665 | ] 666 | }, 667 | { 668 | "cell_type": "code", 669 | "execution_count": 26, 670 | "metadata": {}, 671 | "outputs": [ 672 | { 673 | "name": "stdout", 674 | "output_type": "stream", 675 | "text": [ 676 | "[10 28]\n" 677 | ] 678 | } 679 | ], 680 | "source": [ 681 | "# '@'による内積\n", 682 | "# 行列とベクトルの積になる\n", 683 | "\n", 684 | "y = a @ x\n", 685 | "print(y)" 686 | ] 687 | }, 688 | { 689 | "cell_type": "code", 690 | "execution_count": 27, 691 | "metadata": {}, 692 | "outputs": [ 693 | { 694 | "name": "stdout", 695 | "output_type": "stream", 696 | "text": [ 697 | "[[ 3 4 3]\n", 698 | " [12 10 6]]\n" 699 | ] 700 | } 701 | ], 702 | "source": [ 703 | "# * による積\n", 704 | "# ブロードキャスト機能により要素間の積になる\n", 705 | "\n", 706 | "z = a * x\n", 707 | "print(z)" 708 | ] 709 | }, 710 | { 711 | "cell_type": "markdown", 712 | "metadata": {}, 713 | "source": [ 714 | "#### 特別な配列の生成" 715 | ] 716 | }, 717 | { 718 | "cell_type": "code", 719 | "execution_count": 28, 720 | "metadata": {}, 721 | "outputs": [ 722 | { 723 | "name": "stdout", 724 | "output_type": "stream", 725 | "text": [ 726 | "[[0. 0. 0.]\n", 727 | " [0. 0. 0.]]\n", 728 | "(2, 3)\n" 729 | ] 730 | } 731 | ], 732 | "source": [ 733 | "# 要素数(2,3) すべての要素が0の配列\n", 734 | "\n", 735 | "z23 = np.zeros((2,3))\n", 736 | "print(z23)\n", 737 | "print(z23.shape)" 738 | ] 739 | }, 740 | { 741 | "cell_type": "code", 742 | "execution_count": 29, 743 | "metadata": {}, 744 | "outputs": [ 745 | { 746 | "name": "stdout", 747 | "output_type": "stream", 748 | "text": [ 749 | "[[1. 1. 1.]\n", 750 | " [1. 1. 1.]]\n", 751 | "(2, 3)\n" 752 | ] 753 | } 754 | ], 755 | "source": [ 756 | "# 要素数(2,3) すべての要素が1の配列\n", 757 | "\n", 758 | "o23 = np.ones((2,3))\n", 759 | "print(o23)\n", 760 | "print(o23.shape)" 761 | ] 762 | }, 763 | { 764 | "cell_type": "code", 765 | "execution_count": 30, 766 | "metadata": {}, 767 | "outputs": [ 768 | { 769 | "name": "stdout", 770 | "output_type": "stream", 771 | "text": [ 772 | "[[0.24311266 0.61106348 0.88839895]\n", 773 | " [0.86712057 0.2341609 0.56575314]]\n", 774 | "(2, 3)\n" 775 | ] 776 | } 777 | ], 778 | "source": [ 779 | "# 要素数(2,3) すべての要素が[0,1]間の一様乱数の配列\n", 780 | "\n", 781 | "u23 = np.random.rand(2,3)\n", 782 | "print(u23)\n", 783 | "print(u23.shape)" 784 | ] 785 | }, 786 | { 787 | "cell_type": "code", 788 | "execution_count": 31, 789 | "metadata": {}, 790 | "outputs": [ 791 | { 792 | "name": "stdout", 793 | "output_type": "stream", 794 | "text": [ 795 | "[[ 0.24733984 1.3625211 -0.68888181]\n", 796 | " [ 0.14163477 -2.87562016 0.21906793]]\n", 797 | "(2, 3)\n" 798 | ] 799 | } 800 | ], 801 | "source": [ 802 | "# 要素数(2,3) すべての要素が平均0分散1の正規分布乱数の配列\n", 803 | "\n", 804 | "s23 = np.random.randn(2,3)\n", 805 | "print(s23)\n", 806 | "print(s23.shape)" 807 | ] 808 | }, 809 | { 810 | "cell_type": "code", 811 | "execution_count": null, 812 | "metadata": {}, 813 | "outputs": [], 814 | "source": [] 815 | } 816 | ], 817 | "metadata": { 818 | "kernelspec": { 819 | "display_name": "Python 3", 820 | "language": "python", 821 | "name": "python3" 822 | }, 823 | "language_info": { 824 | "codemirror_mode": { 825 | "name": "ipython", 826 | "version": 3 827 | }, 828 | "file_extension": ".py", 829 | "mimetype": "text/x-python", 830 | "name": "python", 831 | "nbconvert_exporter": "python", 832 | "pygments_lexer": "ipython3", 833 | "version": "3.7.3" 834 | } 835 | }, 836 | "nbformat": 4, 837 | "nbformat_minor": 1 838 | } 839 | -------------------------------------------------------------------------------- /notebooks/15-matplotlib.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Matplotlib入門" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "### Matplotlibとは\n", 15 | "\n", 16 | "PythonのJupyter Notebook環境でグラフ表示を行うためのライブラリです。 \n", 17 | "NumpyやPandasとの連携を前提に設計されており、簡潔なコードで様々なグラフ表示を行うことができます。 \n", 18 | "以下は7章の線形回帰の実習で出てくるMatplotlib呼出しコードの解説です。 \n", 19 | "(書籍内では説明が省かれています)" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": {}, 25 | "source": [ 26 | "#### データ準備\n", 27 | "Numpy2で解説したコードなので、説明は省略します。" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 1, 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "# 必要ライブラリimport\n", 37 | "import numpy as np\n", 38 | "from sklearn.datasets import load_boston\n", 39 | "\n", 40 | "boston = load_boston()\n", 41 | "x_org, yt = boston.data, boston.target\n", 42 | "feature_names = boston.feature_names\n", 43 | "\n", 44 | "x_data = x_org[:,feature_names == 'RM']\n", 45 | "x = np.insert(x_data, 0, 1.0, axis=1)" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "#### 散布図の表示" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": 2, 58 | "metadata": {}, 59 | "outputs": [], 60 | "source": [ 61 | "# 必要ライブラリimport\n", 62 | "%matplotlib inline\n", 63 | "import matplotlib.pyplot as plt" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 3, 69 | "metadata": {}, 70 | "outputs": [ 71 | { 72 | "data": { 73 | "image/png": "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\n", 74 | "text/plain": [ 75 | "
" 76 | ] 77 | }, 78 | "metadata": { 79 | "needs_background": "light" 80 | }, 81 | "output_type": "display_data" 82 | } 83 | ], 84 | "source": [ 85 | "# 散布図の表示\n", 86 | "\n", 87 | "# 散布図は scatter関数で表示します。\n", 88 | "# 第一引数 xの値の配列 (例では x[:,1])\n", 89 | "# 第二引数 yの値の配列 (例ではyt)\n", 90 | "# s: 点の大きさ (オプション)\n", 91 | "# c: 色指定 (オプション)\n", 92 | "plt.scatter(x[:,1], yt, s=10, c='b')\n", 93 | "\n", 94 | "# xlabel: x軸のラベル表示\n", 95 | "plt.xlabel('ROOM', fontsize=14)\n", 96 | "\n", 97 | "# ylabel: ｙ軸のラベル表示\n", 98 | "plt.ylabel('PRICE', fontsize=14)\n", 99 | "\n", 100 | "# 画面描画を明示的に指示\n", 101 | "plt.show()" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "#### グラフ表示\n", 109 | "7章では学習曲線の表示にplot関数が使われています。 \n", 110 | "学習曲線の計算は大変なので、代わりに5章で出てくるシグモイド関数のグラフ表示コードを示します。" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 4, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [ 119 | "# シグモイド関数の定義\n", 120 | "def sigmoid(x):\n", 121 | " return 1/(1 + np.exp(-x))" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": 5, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [ 130 | "# xの配列作成\n", 131 | "# linescapeは与えられた区間の間に等間隔の点を取る関数です。\n", 132 | "# 下記の例では 区間[-5, 5]の間に101個の点を取ります。\n", 133 | "\n", 134 | "x = np.linspace(-5, 5, 101)" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 6, 140 | "metadata": {}, 141 | "outputs": [ 142 | { 143 | "name": "stdout", 144 | "output_type": "stream", 145 | "text": [ 146 | "[-5. -4.9 -4.8 -4.7 -4.6]\n" 147 | ] 148 | } 149 | ], 150 | "source": [ 151 | "# xの内容表示(一部)\n", 152 | "print(x[:5])" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": 7, 158 | "metadata": {}, 159 | "outputs": [], 160 | "source": [ 161 | "# yの配列作成\n", 162 | "y = sigmoid(x)" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 8, 168 | "metadata": {}, 169 | "outputs": [ 170 | { 171 | "name": "stdout", 172 | "output_type": "stream", 173 | "text": [ 174 | "[0.00669285 0.00739154 0.00816257 0.0090133 0.0099518 ]\n" 175 | ] 176 | } 177 | ], 178 | "source": [ 179 | "# yの内容表示(一部)\n", 180 | "print(y[:5])" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": 9, 186 | "metadata": {}, 187 | "outputs": [ 188 | { 189 | "data": { 190 | "image/png": "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\n", 191 | "text/plain": [ 192 | "
" 193 | ] 194 | }, 195 | "metadata": { 196 | "needs_background": "light" 197 | }, 198 | "output_type": "display_data" 199 | } 200 | ], 201 | "source": [ 202 | "# グラフ表示\n", 203 | "\n", 204 | "# グラフ表示はplot関数で描画する\n", 205 | "# 第一引数: xの配列\n", 206 | "# 第二引数: yの配列\n", 207 | "# label: グラフのラベル指定(オプション)\n", 208 | "plt.plot(x, y, label='sigmoid')\n", 209 | "\n", 210 | "# グラフ上にグリッド表示を追加\n", 211 | "plt.grid()\n", 212 | "\n", 213 | "# グラフ上に凡例表示を追加\n", 214 | "plt.legend()\n", 215 | "\n", 216 | "# 画面描画を明示的に指示\n", 217 | "plt.show()" 218 | ] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "execution_count": null, 223 | "metadata": {}, 224 | "outputs": [], 225 | "source": [] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": null, 230 | "metadata": {}, 231 | "outputs": [], 232 | "source": [] 233 | } 234 | ], 235 | "metadata": { 236 | "kernelspec": { 237 | "display_name": "Python 3", 238 | "language": "python", 239 | "name": "python3" 240 | }, 241 | "language_info": { 242 | "codemirror_mode": { 243 | "name": "ipython", 244 | "version": 3 245 | }, 246 | "file_extension": ".py", 247 | "mimetype": "text/x-python", 248 | "name": "python", 249 | "nbconvert_exporter": "python", 250 | "pygments_lexer": "ipython3", 251 | "version": "3.7.3" 252 | } 253 | }, 254 | "nbformat": 4, 255 | "nbformat_minor": 1 256 | } 257 | -------------------------------------------------------------------------------- /notebooks/exams/15-matplotlib-exam.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Matplotlib課題" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "下記のシグモイド関数グラフ描画のコードを参考にして、sin関数のグラフを描画して下さい。\n", 15 | "但し、xの値域は$[0, 6\\pi]$ とします。" 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 1, 21 | "metadata": {}, 22 | "outputs": [], 23 | "source": [ 24 | "# 必要ライブラリimport\n", 25 | "import numpy as np\n", 26 | "%matplotlib inline\n", 27 | "import matplotlib.pyplot as plt" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 2, 33 | "metadata": {}, 34 | "outputs": [ 35 | { 36 | "data": { 37 | "image/png": "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\n", 38 | "text/plain": [ 39 | "
" 40 | ] 41 | }, 42 | "metadata": { 43 | "needs_background": "light" 44 | }, 45 | "output_type": "display_data" 46 | } 47 | ], 48 | "source": [ 49 | "def sigmoid(x):\n", 50 | " return 1/(1 + np.exp(-x))\n", 51 | "\n", 52 | "x = np.linspace(-5, 5, 101)\n", 53 | "y = sigmoid(x)\n", 54 | "\n", 55 | "plt.plot(x, y, label='sigmoid')\n", 56 | "plt.grid()\n", 57 | "plt.legend()\n", 58 | "plt.show()" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "以下にsin関数のグラフ描画のコードを実装して下さい。\n", 66 | "ヒント：\n", 67 | "sin関数 ``np.sin``\n", 68 | "$\\pi$は、``np.pi``を使って下さい。" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 4, 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "data": { 78 | "image/png": "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\n", 79 | "text/plain": [ 80 | "
" 81 | ] 82 | }, 83 | "metadata": { 84 | "needs_background": "light" 85 | }, 86 | "output_type": "display_data" 87 | } 88 | ], 89 | "source": [] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [] 97 | } 98 | ], 99 | "metadata": { 100 | "kernelspec": { 101 | "display_name": "Python 3", 102 | "language": "python", 103 | "name": "python3" 104 | }, 105 | "language_info": { 106 | "codemirror_mode": { 107 | "name": "ipython", 108 | "version": 3 109 | }, 110 | "file_extension": ".py", 111 | "mimetype": "text/x-python", 112 | "name": "python", 113 | "nbconvert_exporter": "python", 114 | "pygments_lexer": "ipython3", 115 | "version": "3.7.3" 116 | } 117 | }, 118 | "nbformat": 4, 119 | "nbformat_minor": 2 120 | } 121 | --------------------------------------------------------------------------------