From 229b6ee77e10d3eaa77ff668dcd3fb946b70c2e6 Mon Sep 17 00:00:00 2001 From: hanhuijin <60727234+hanhuijin@users.noreply.github.com> Date: Mon, 12 Oct 2020 17:39:29 +0800 Subject: [PATCH] =?UTF-8?q?=E7=BB=84=E9=98=9F=E5=AD=A6=E4=B9=A0=E8=B5=84?= =?UTF-8?q?=E6=96=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../练习-数组操作-变形-答案.ipynb | 108 ++++++++++++- .../练习-数组操作-变形.ipynb | 39 +++-- .../练习--数学函数，逻辑函数-答案.ipynb | 151 +++++++++++++++++- .../练习--数学函数，逻辑函数.ipynb | 42 ++++- 4 files changed, 323 insertions(+), 17 deletions(-) diff --git a/IntroductionToNumpy/task03 数组的操作-变形/练习-数组操作-变形-答案.ipynb b/IntroductionToNumpy/task03 数组的操作-变形/练习-数组操作-变形-答案.ipynb index e5c2177..85114d7 100644 --- a/IntroductionToNumpy/task03 数组的操作-变形/练习-数组操作-变形-答案.ipynb +++ b/IntroductionToNumpy/task03 数组的操作-变形/练习-数组操作-变形-答案.ipynb @@ -180,6 +180,75 @@ "# [5 6 7 8 9 1 1 1 1 1]]" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**将 `arr`的2维数组按列输出。**\n", + "- `arr = np.array([[16, 17, 18, 19, 20],[11, 12, 13, 14, 15],[21, 22, 23, 24, 25],[31, 32, 33, 34, 35],[26, 27, 28, 29, 30]])`\n", + "\n", + "【知识点：数组的操作】\n", + "- 如何访问二维数组的全部元素，并按列输出？" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[16 11 21 31 26 17 12 22 32 27 18 13 23 33 28 19 14 24 34 29 20 15 25 35\n", + " 30]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "arr = np.array([[16, 17, 18, 19, 20],[11, 12, 13, 14, 15],[21, 22, 23, 24, 25],[31, 32, 33, 34, 35],[26, 27, 28, 29, 30]])\n", + "y = arr.flatten(order='F')\n", + "print(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**给定两个随机数组A和B，验证它们是否相等。**\n", + "\n", + "- `A = np.random.randint(0,2,5) B = np.random.randint(0,2,5)`" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "A = np.array([1,2,3])\n", + "B = np.array([1,2,3])\n", + "\n", + "# Assuming identical shape of the arrays and a tolerance for the comparison of values\n", + "equal = np.allclose(A,B)\n", + "print(equal)\n", + "\n", + "# Checking both the shape and the element values, no tolerance (values have to be exactly equal)\n", + "equal = np.array_equal(A,B)\n", + "print(equal)" + ] + }, { "cell_type": "markdown", "metadata": { @@ -235,6 +304,41 @@ "metadata": {}, "source": [] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**建立一个随机数在1-10之间的3行2列的数组，并将其转换成2行3列的数组。**\n", + "\n", + "【知识点：数组的操作】\n", + "- 改变数组形状？" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[9 0]\n", + " [3 3]\n", + " [4 6]]\n", + "[[9 0 3]\n", + " [3 4 6]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x = np.random.randint(10, size=[3, 2])\n", + "print(x)\n", + "y = np.reshape(x, [2,3])\n", + "print(y)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -245,9 +349,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python35", + "display_name": "Python 3", "language": "python", - "name": "python35" + "name": "python3" }, "language_info": { "codemirror_mode": { diff --git a/IntroductionToNumpy/task03 数组的操作-变形/练习-数组操作-变形.ipynb b/IntroductionToNumpy/task03 数组的操作-变形/练习-数组操作-变形.ipynb index cdcf890..8722a67 100644 --- a/IntroductionToNumpy/task03 数组的操作-变形/练习-数组操作-变形.ipynb +++ b/IntroductionToNumpy/task03 数组的操作-变形/练习-数组操作-变形.ipynb @@ -27,7 +27,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### **8. 将数组a与数组b水平堆叠。**\n", + "### 将数组a与数组b水平堆叠。\n", "- `a = np.arange(10).reshape([2, -1])`\n", "- `b = np.repeat(1, 10).reshape([2, -1])`\n", "\n", @@ -35,6 +35,30 @@ "- 如何水平叠加两个数组？" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **将 `arr`的2维数组按列输出。**\n", + "\n", + "- `arr = np.array([[16, 17, 18, 19, 20],[11, 12, 13, 14, 15],[21, 22, 23, 24, 25],[31, 32, 33, 34, 35],[26, 27, 28, 29, 30]])`\n", + "\n", + "【知识点：数组的操作】\n", + "- 如何访问二维数组的全部元素，并按列输出？" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **给定两个随机数组A和B，验证它们是否相等。**\n", + "\n", + "- `A = np.random.randint(0,2,5) B = np.random.randint(0,2,5)`\n", + "\n", + "【知识点：数组的操作】\n", + "- np.allclose()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -46,20 +70,13 @@ "【知识点：数组操作】\n", "- 如何在numpy数组中找到重复值？" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python35", + "display_name": "Python 3", "language": "python", - "name": "python35" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -84,7 +101,7 @@ "toc_cell": false, "toc_position": {}, "toc_section_display": true, - "toc_window_display": false + "toc_window_display": true }, "varInspector": { "cols": { diff --git a/IntroductionToNumpy/task04 数学函数及逻辑函数/练习--数学函数，逻辑函数-答案.ipynb b/IntroductionToNumpy/task04 数学函数及逻辑函数/练习--数学函数，逻辑函数-答案.ipynb index d02b03d..805f41a 100644 --- a/IntroductionToNumpy/task04 数学函数及逻辑函数/练习--数学函数，逻辑函数-答案.ipynb +++ b/IntroductionToNumpy/task04 数学函数及逻辑函数/练习--数学函数，逻辑函数-答案.ipynb @@ -397,6 +397,116 @@ "print (distance(P0, P1, p))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **画正弦函数和余弦函数， x = np.arange(0, 3 * np.pi, 0.1)？**" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "x = np.arange(0, 3*np.pi, 0.1)\n", + "y1 = np.sin(x)\n", + "y2 = np.cos(x)\n", + "plt.plot(x, y1)\n", + "plt.plot(x, y2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**减去矩阵每一行的平均值 ？**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-0.22611265 0.18681928 0.13113673 -0.42713648 0.13273158 0.01160406\n", + " 0.54266804 -0.15637426 0.16445073 -0.35978702]\n", + " [-0.34359842 0.26798252 0.35328871 0.40386463 -0.45020099 0.40738698\n", + " 0.10061077 -0.32664784 0.1162996 -0.52898595]\n", + " [ 0.08892378 -0.10264121 0.27575287 -0.00792712 0.01868823 0.18782665\n", + " 0.00795426 -0.12014542 -0.35177329 0.00334125]\n", + " [-0.46156881 -0.40474198 0.15298977 0.17155644 0.17332436 -0.06791347\n", + " -0.12123457 0.00349192 0.28866751 0.26542884]\n", + " [-0.39891856 -0.01008639 0.50523343 -0.28914192 0.01382436 -0.15406104\n", + " -0.22350635 0.45768516 -0.17832199 0.2772933 ]]\n" + ] + } + ], + "source": [ + "X = np.random.rand(5, 10)\n", + "# 新\n", + "Y = X - X.mean(axis=1, keepdims=True)\n", + "# 旧\n", + "Y = X - X.mean(axis=1).reshape(-1, 1)\n", + "print(Y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**进行概率统计分析 ？**\n", + "- `arr1 = np.random.randint(1,10,10)\n", + "arr2 = np.random.randint(1,10,10))`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "f\n", + "arr1 = np.random.randint(1,10,10)\n", + "arr2 = np.random.randint(1,10,10)\n", + "\n", + "print(\"arr1的平均数为:%s\" %np.mean(arr1))\n", + "print(\"arr1的中位数为:%s\" %np.median(arr1))\n", + "print(\"arr1的方差为:%s\" %np.var(arr1))\n", + "print(\"arr1的标准差为:%s\" %np.std(arr1))\n", + "print(\"arr1,arr的相关性矩阵为:%s\" %np.cov(arr1,arr2))\n", + "print(\"arr1,arr的协方差矩阵为:%s\" %np.corrcoef(arr1,arr2))" + ] + }, { "cell_type": "markdown", "metadata": { @@ -642,13 +752,50 @@ "print(Z)\n", "np.negative(Z, out=Z)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**找出数组中与给定值最接近的数**" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0 1 2 3]\n", + " [4 5 6 7]]\n", + "5\n" + ] + } + ], + "source": [ + "Z=np.array([[0,1,2,3],[4,5,6,7]])\n", + "print(Z)\n", + "z=5.1\n", + "np.abs(Z - z).argmin()\n", + "print(Z.flat[np.abs(Z - z).argmin()])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python35", + "display_name": "Python 3", "language": "python", - "name": "python35" + "name": "python3" }, "language_info": { "codemirror_mode": { diff --git a/IntroductionToNumpy/task04 数学函数及逻辑函数/练习--数学函数，逻辑函数.ipynb b/IntroductionToNumpy/task04 数学函数及逻辑函数/练习--数学函数，逻辑函数.ipynb index 885672e..1920cb1 100644 --- a/IntroductionToNumpy/task04 数学函数及逻辑函数/练习--数学函数，逻辑函数.ipynb +++ b/IntroductionToNumpy/task04 数学函数及逻辑函数/练习--数学函数，逻辑函数.ipynb @@ -100,6 +100,34 @@ "则P到直线的距离为:d=|Ax0+By0+C|/√(A²+B²)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **画正弦函数和余弦函数， x = np.arange(0, 3 * np.pi, 0.1)？**\n", + "【知识点：数学函数】" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **减去矩阵每一行的平均值 ？**\n", + "【知识点：数学函数】\n", + "- 提示: mean(axis=,keepdims=)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **进行概率统计分析 ？**\n", + "- `arr1 = np.random.randint(1,10,10)\n", + "arr2 = np.random.randint(1,10,10))\n", + "【知识点：数学函数】 \n", + "平均数，中位数，方差，标准差，相关性矩阵，协方差矩阵等`\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -153,6 +181,16 @@ "- (提示: np.logical_not, np.negative)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **找出数组中与给定值最接近的数**\n", + "\n", + "【知识点：逻辑函数】\n", + "- (提示: np.abs().argmin())" + ] + }, { "cell_type": "code", "execution_count": null, @@ -163,9 +201,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python35", + "display_name": "Python 3", "language": "python", - "name": "python35" + "name": "python3" }, "language_info": { "codemirror_mode": {