{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "A69AC7A8D039456492A58F4670474397",
"jupyter": {},
"mdEditEnable": false,
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"Numpy是Python做数据分析所必须要掌握的基础库之一。\n",
"\n",
"\n",
"---\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "D3EA769E89C04B1C98D7EEC27B000CF7",
"jupyter": {},
"mdEditEnable": false,
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 1. 导入```numpy```库并简写为 `np` (★☆☆) \n",
"(**提示**: ```import … as …```)"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": true,
"id": "9D78D931517E432FA973C0DFF57BC78B",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# import numpy as np"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "20AFD585027B441186903FB6F16CAA77",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 2. 打印```numpy```的版本和配置说明 (★☆☆) \n",
"(**提示**: ```np.__version__, np.show_config```)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": true,
"id": "D705477270FF47D69C42E337B57DFC10",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(np.__version__)\n",
"# np.show_config()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "1E6BD3752DEF4E698704E50AA0EBE92C",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 3. 创建一个长度为10的空向量 (★☆☆) \n",
"(**提示**: ```np.zeros```)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": true,
"id": "41292630A6F64C3391CF4AC90606EB62",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.zeros(10)\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "C8C4597CD9F1403BAD09C3601BFB771B",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 4. 如何找到任何一个数组的内存大小？ (★☆☆)\n",
"(**提示**: ```size, itemsize```)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": true,
"id": "42640A317E3544118E6C4E76DED8525C",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.zeros((10,10))\n",
"# print(\"%d bytes\" % (Z.size * Z.itemsize))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "04C04BB115BD4AF687192E229581A9C1",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 5. 如何从命令行得到```numpy```中```add```函数的说明文档? (★☆☆) \n",
"(**提示**: ```np.info```)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": true,
"id": "9138EB4B567942018EF386A8DB116F60",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# numpy.info(numpy.add)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "7BEAD42C1F124A88851E1D4766DC2FDC",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 6. 创建一个长度为10并且除了第五个值为1的空向量 (★☆☆) \n",
"(**提示**: ```array[4]```)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": true,
"id": "C28FC474E3124C97AA0E95DE2AE6DDED",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.zeros(10)\n",
"# Z[4] = 1\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CA86859BD5FE44888383B564D3281A88",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 7. 创建一个值域范围从10到49的向量(★☆☆) \n",
"(**提示**: ```np.arange```)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": true,
"id": "3C0F52C0DD8B42C0908DA28387686BF5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(10,50)\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8E233C2183494F5185095C23FD390953",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 8. 反转一个向量(第一个元素变为最后一个) (★☆☆) \n",
"(**提示**: ```array[::-1]```)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": true,
"id": "AE86CCAF12044CED8445E5476F0EC695",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(50)\n",
"# Z = Z[::-1]\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "9ABF19E9BDDF41E6BDD0EC15890B452B",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 9. 创建一个 ```3x3``` 并且值从0到8的矩阵(★☆☆) \n",
"(**提示**: ```reshape```)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": true,
"id": "FE30B2979C01496681E90910A011A276",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(9).reshape(3,3)\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8FF7AF19C2344E37BFDE905F618E47E9",
"jupyter": {},
"mdEditEnable": false,
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 10. 找到数组```[1,2,0,0,4,0]```中非0元素的位置索引 (★☆☆) \n",
"(**提示**: ```np.nonzero```)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": true,
"id": "CF6B96A0E8FA4FB588249E6E6DB89657",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# nz = np.nonzero([1,2,0,0,4,0])\n",
"# print(nz)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "B431E1E8247640A58BDAACA967F5E104",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 11. 创建一个 ```3x3``` 的单位矩阵 (★☆☆) \n",
"(**提示**: ```np.eye```)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": true,
"id": "B09137867EFA48C4AA58DBCB0F3AE455",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.eye(3)\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8C4D8FCF233D43B28DC51B81879D4EA3",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 12. 创建一个 ```3x3x3```的随机数组 (★☆☆) \n",
"(**提示**: ```np.random.random```)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": true,
"id": "7B99B6FBF2594BF7862AC75134813F8C",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.random((3,3,3))\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "F566B47F9E574BE1876B8AF746BB1410",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 13. 创建一个 ```10x10``` 的随机数组并找到它的最大值和最小值 (★☆☆) \n",
"(**提示**: ```min, max```)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": true,
"id": "69474CA4E1B144DB9DFEC144DED5EA34",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.random((10,10))\n",
"# Zmin, Zmax = Z.min(), Z.max()\n",
"# print(Zmin, Zmax)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "1C91060ECCFD4CCB8DC6849C4DA5F6B1",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 14. 创建一个长度为30的随机向量并找到它的平均值 (★☆☆) \n",
"(**提示**: ```mean```)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": true,
"id": "4CC6FD8D2EE94C5CB9C016F753FECA6F",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.random(30)\n",
"# m = Z.mean()\n",
"# print(m)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3BB48A32125C46FF8595C4BD8496BDF2",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 15. 创建一个二维数组，其中边界值为1，其余值为0 (★☆☆) \n",
"(**提示**: ```array[1:-1, 1:-1]```)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": true,
"id": "DD81EF89D40347959726C00E6D4960FB",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.ones((10,10))\n",
"# Z[1:-1,1:-1] = 0\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3E757B4834EC47038E1BE151D9216D24",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 16. 对于一个存在在数组，如何添加一个用0填充的边界? (★☆☆) \n",
"(**提示**: ```np.pad```)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": true,
"id": "50C827FEF7494D648C5851A1892D781E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.ones((5,5))\n",
"# Z = np.pad(Z, pad_width=1, mode='constant', constant_values=0)\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "91F10E5D65C245C28315A74D340DE25E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 17. 以下表达式运行的结果分别是什么? (★☆☆) \n",
"(**提示**: ```NaN = not a number, inf = infinity```)\n",
"```python\n",
"0 * np.nan\n",
"np.nan == np.nan\n",
"np.inf > np.nan\n",
"np.nan - np.nan\n",
"0.3 == 3 * 0.1\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": true,
"id": "5099C44330384C148B6C75BB8F8B0C1C",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(0 * np.nan)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": true,
"id": "6B26448558014F8E811F947E38EA0CC3",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(np.nan == np.nan)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": true,
"id": "2250DCFDAF35421782B8468BAD931692",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(np.inf > np.nan)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": true,
"id": "FDB7272792FA413FB8E610D62DE2645F",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(np.nan - np.nan)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": true,
"id": "B991F0C2294442B38127DA786ACFAA8E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(0.3 == 3 * 0.1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4019417908674DE49895DAF9E9806F2E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 18. 创建一个 ```5x5```的矩阵，并设置值1,2,3,4落在其对角线下方位置 (★☆☆) \n",
"(**提示**: ```np.diag```)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": true,
"id": "712527DF95664A3A8C6568BB2A5D08C6",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.diag(1+np.arange(4),k=-1)\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4B0E4200FE8A48D1852A71D9120E6003",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 19. 创建一个``` 8x8``` 的矩阵，并且设置成棋盘样式 (★☆☆) \n",
"(**提示**: ```array[::2]```)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"collapsed": true,
"id": "2C5E5A07FD84446780749AC3E09D72F6",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.zeros((8,8),dtype=int)\n",
"# Z[1::2,::2] = 1\n",
"# Z[::2,1::2] = 1\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "C161AAFC72C74F98999DA7C3326DFC07",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 20. 考虑一个 (6,7,8) 形状的数组，其第100个元素的索引(x,y,z)是什么? \n",
"(**提示**: ```np.unravel_index```)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"collapsed": true,
"id": "35A916EDE9F34778949694347D7EED5F",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(np.unravel_index(100,(6,7,8)))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "DBC41AC1D41E43F98B4D0A270F1E6987",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 21. 用```tile```函数去创建一个 ```8x8```的棋盘样式矩阵(★☆☆) \n",
"(**提示**: ```np.tile```)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"collapsed": true,
"id": "44FFB3BC499C4CE3AFD4B81B2EBADD1E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.tile( np.array([[0,1],[1,0]]), (4,4))\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "92086F95E7ED4E8091C40BECE2606018",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 22. 对一个```5x5```的随机矩阵做归一化(★☆☆) \n",
"(**提示**: ```(x - min) / (max - min)```)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"collapsed": true,
"id": "44305FE5FF3545C1B4E80254CE276D30",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.random((5,5))\n",
"# Zmax, Zmin = Z.max(), Z.min()\n",
"# Z = (Z - Zmin)/(Zmax - Zmin)\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "31DDD5EC850B456C8ED766880CB032B1",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 23. 创建一个将颜色描述为(RGBA)四个无符号字节的自定义```dtype```？(★☆☆) \n",
"(**提示**: ```np.dtype```)"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"collapsed": true,
"id": "F5033802C2EC41768FA02565B2116391",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# color = np.dtype([(\"r\", np.ubyte, 1),\n",
"# (\"g\", np.ubyte, 1),\n",
"# (\"b\", np.ubyte, 1),\n",
"# (\"a\", np.ubyte, 1)])\n",
"# color"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "90D1829F563F4B338D9C333B0A5E6F06",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 24. 一个```5x3```的矩阵与一个```3x2```的矩阵相乘，实矩阵乘积是什么？ (★☆☆) \n",
"(**提示**: ```np.dot | @```)"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"collapsed": true,
"id": "E5F4646106CD449DB590BE25CD6FBF27",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.dot(np.ones((5,3)), np.ones((3,2)))\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2BC071A5CE5448D28C1A9FDEE2D02F4E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 25. 给定一个一维数组，对其在3到8之间的所有元素取反 (★☆☆) \n",
"(**提示**: ```>, <=```)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"collapsed": true,
"id": "23E937FDBAE043FAB0192B316A6D6F3E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(11)\n",
"# Z[(3 < Z) & (Z <= 8)] *= -1\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "A72EC713523C4CEF97ADA412621678D5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 26. 下面脚本运行后的结果是什么? (★☆☆) \n",
"(**提示**: np.sum)\n",
"```python\n",
"print(sum(range(5),-1))\n",
"from numpy import *\n",
"print(sum(range(5),-1))\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"collapsed": true,
"id": "519A129944AC4CF58C6985F559BC3881",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(sum(range(5),-1))"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"collapsed": true,
"id": "EDD3AF4393074CF98A5B2754552443BE",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# from numpy import *\n",
"# print(sum(range(5),-1))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "42932F8259944D7E80D5C79D8B38A320",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 27. 考虑一个整数向量Z,下列表达合法的是哪个? (★☆☆)\n",
"```python\n",
"Z**Z\n",
"2 << Z >> 2\n",
"Z <- Z\n",
"1j*Z\n",
"Z/1/1\n",
"Z<Z>Z\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"collapsed": true,
"id": "E99C3DCEB8FB4200AA60D4DCF22EB2A8",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(5)\n",
"# Z ** Z # legal"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"collapsed": true,
"id": "D81A330CCEA2479E8E781EA468D3C68A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(5)\n",
"# 2 << Z >> 2 # false"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": true,
"id": "E1E168B997BE48ED8ED1AA507D5BC20C",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(5)\n",
"# Z <- Z # legal"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"collapsed": true,
"id": "A72D8CF7DBA14202830DDE74AC0FDFAF",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(5)\n",
"# 1j*Z # legal"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"collapsed": true,
"id": "BB7023C33FA6455C89362695EACC78F4",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(5)\n",
"# Z/1/1 # legal"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"collapsed": true,
"id": "90BF25CACF044F6F8937CC226A1E781A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(5)\n",
"# Z<Z>Z # false"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AFDD8E04D3C2492CA81547489A2FB3FD",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 28. 下列表达式的结果分别是什么?(★☆☆) \n",
"```python\n",
"np.array(0) / np.array(0)\n",
"np.array(0) // np.array(0)\n",
"np.array([np.nan]).astype(int).astype(float)\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"collapsed": true,
"id": "A719B41935824F908DFE6CD47FF24B9F",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(np.array(0) / np.array(0))"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"collapsed": true,
"id": "E4EE66660AF2480B9C83C147878295E5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(np.array(0) // np.array(0))"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": true,
"id": "B42B92AB0C6D4F948AF26CBE383CCC67",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print(np.array([np.nan]).astype(int).astype(float))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "D021C8ACC0D940DA994E073486BE2C9C",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 29. 如何从零位对浮点数组做舍入 ? (★☆☆) \n",
"(**提示**: ```np.uniform, np.copysign, np.ceil, np.abs```)"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"collapsed": true,
"id": "D9EE837214154F149529C76396C2EE79",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.uniform(-10,+10,10)\n",
"# print (np.copysign(np.ceil(np.abs(Z)), Z))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "06D7AFD7163D49BC8C20348EA26C54C9",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 30. 如何找到两个数组中的共同元素? (★☆☆) \n",
"(**提示**: ```np.intersect1d```)"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"collapsed": true,
"id": "D2A344B9FCC94DDCBB82EC94CE3DD668",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z1 = np.random.randint(0,10,10)\n",
"# Z2 = np.random.randint(0,10,10)\n",
"# print(np.intersect1d(Z1,Z2))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "1573CCEE2F754648879030F4866898B9",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 31. 如何忽略所有的 ```numpy``` 警告(尽管不建议这么做)? (★☆☆) \n",
"(**提示**: ```np.seterr, np.errstate```)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "9D273F962459416BB206C0F93F2F8D08",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"```python\n",
"# Suicide mode on\n",
"defaults = np.seterr(all=\"ignore\")\n",
"Z = np.ones(1) / 0\n",
"\n",
"# Back to sanity\n",
"_ = np.seterr(**defaults)\n",
"\n",
"An equivalent way, with a context manager:\n",
"\n",
"with np.errstate(divide='ignore'):\n",
" Z = np.ones(1) / 0\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "C513CAD2620F417FAD6D8859C3AF1883",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 32. 下面的表达式是正确的吗? (★☆☆) \n",
"(**提示**: imaginary number)\n",
"```python\n",
"np.sqrt(-1) == np.emath.sqrt(-1)\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"collapsed": true,
"id": "7B70B61A32D04CF68CDD1D44A0C2C19B",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# np.sqrt(-1) == np.emath.sqrt(-1) # False"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "A45D7F283E0B456E81829DDEF2E13FE5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 33. 如何得到昨天，今天，明天的日期? (★☆☆) \n",
"(**提示**: ```np.datetime64, np.timedelta64```)"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"collapsed": true,
"id": "031F2BA107374ED6837FCAC6F96884E5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D')\n",
"# today = np.datetime64('today', 'D')\n",
"# tomorrow = np.datetime64('today', 'D') + np.timedelta64(1, 'D')\n",
"# print (\"Yesterday is \" + str(yesterday))\n",
"# print (\"Today is \" + str(today))\n",
"# print (\"Tomorrow is \"+ str(tomorrow))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "9DDDA7EE921A4674B754BB8E40F1CCAE",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 34. 如何得到所有与2016年7月对应的日期？ (★★☆) \n",
"(**提示**: ```np.arange(dtype=datetime64['D'])```)"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": true,
"id": "B937D12F01784CFE84E214718F9A3CBC",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange('2016-07', '2016-08', dtype='datetime64[D]')\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AAC83583B8EC400687E5505ECAE0E435",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 35. 如何直接在位计算```(A+B)\\*(-A/2)```(不建立副本)? (★★☆) \n",
"(**提示**: ```np.add(out=), np.negative(out=), np.multiply(out=), np.divide(out=)```)"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"collapsed": true,
"id": "E686188C9965478DBCA16C3FF4853052",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# A = np.ones(3)*1\n",
"# B = np.ones(3)*2\n",
"# C = np.ones(3)*3\n",
"# np.add(A,B,out=B)"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"collapsed": true,
"id": "AA936812BA394FA187A4B3B17581AB23",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# np.divide(A,2,out=A)"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"collapsed": true,
"id": "929DE1B8AA494C76B855CC88ACBAAF48",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# np.negative(A,out=A)"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"collapsed": true,
"id": "FDA87EC072CD4B9A907321B926C41407",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# np.multiply(A,B,out=A)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "502537DCE0AA46E387883CF90133D718",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 36. 用五种不同的方法去提取一个随机数组的整数部分(★★☆) \n",
"(**提示**: ```%, np.floor, np.ceil, astype, np.trunc```)"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"collapsed": true,
"id": "A58464DF10D34B8A8BFA134D44C9CF56",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.uniform(0,10,10)\n",
"\n",
"# print (Z - Z%1)"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"collapsed": true,
"id": "6B2201271C154961B7928E1EFF540CBB",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print (np.floor(Z))"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"collapsed": true,
"id": "58363BA8D19D4BC2A578159905B71B46",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print (np.ceil(Z)-1)"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"collapsed": true,
"id": "6745FA7466464D18BE4FDBAC96EEA98D",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print (Z.astype(int))"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"collapsed": true,
"id": "5543995A0FD14D378AD7CA4F84D621E6",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print (np.trunc(Z))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "E9BC7D19D7214712BEBECE1FBA90C5B4",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 37. 创建一个```5x5```的矩阵，其中每行的数值范围从0到4 (★★☆) \n",
"(**提示**: ```np.arange```)"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"collapsed": true,
"id": "F046ACCD114749428AD0A7AD10DF76E8",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.zeros((5,5))\n",
"# Z += np.arange(5)\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "011C9D30472C49438273D09B10DE1257",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 38. 通过考虑一个可生成10个整数的函数，来构建一个数组(★☆☆) \n",
"(**提示**: ```np.fromiter```)"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"collapsed": true,
"id": "B19FAA5F434E4770B56B36D8EACEF3ED",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# def generate():\n",
"# for x in range(10):\n",
"# yield x\n",
"# Z = np.fromiter(generate(),dtype=float,count=-1)\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "29274F560F6244E2832804107CD1BDD5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 39. 创建一个长度为10的随机向量，其值域范围从0到1，但是不包括0和1 (★★☆) \n",
"(**提示**: ```np.linspace```)"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"collapsed": true,
"id": "EE10F710B4F844FC81A16EF7777F229B",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.linspace(0,1,11,endpoint=False)[1:]\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "F8583210BCF048B9B313B36BEEC4DE67",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 40. 创建一个长度为10的随机向量，并将其排序 (★★☆) \n",
"(**提示**: ```sort```)"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"collapsed": true,
"id": "CBFC87DACC404D6289933C746DFC0735",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.random(10)\n",
"# Z.sort()\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "C19BB964416F4F7586F1996ABC00373E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 41.对于一个小数组，如何用比 ```np.sum```更快的方式对其求和？(★★☆) \n",
"(**提示**: ```np.add.reduce```)"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"collapsed": true,
"id": "47573260DA734DA7A9C654D6DC754C49",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(10)\n",
"# np.add.reduce(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "0AA3A2F5B19F47A19318A13D5888FC99",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 42. 对于两个随机数组A和B，检查它们是否相等(★★☆) \n",
"(**提示**: ```np.allclose, np.array_equal```)"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"collapsed": true,
"id": "1448EB4CCEF54A9BB5C6CDECCBC556B5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# A = np.random.randint(0,2,5)\n",
"# B = np.random.randint(0,2,5)\n",
"# # Assuming identical shape of the arrays and a tolerance for the comparison of values\n",
"# equal = np.allclose(A,B)\n",
"# print(equal)"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"collapsed": true,
"id": "A9479E221501459597EA782EA19CB7C2",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# # 方法2\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": {
"id": "19B0C351B16F4FE6A88CAA9F8845EA8A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 43. 创建一个只读数组(read-only) (★★☆) \n",
"(**提示**: ```flags.writeable```)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "B7E6E1870CAB44BC8209B4C5501FE767",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"```python\n",
"# 使用如下过程实现\n",
"Z = np.zeros(10)\n",
"Z.flags.writeable = False\n",
"Z[0] = 1\n",
"---------------------------------------------------------------------------\n",
"ValueError Traceback (most recent call last)\n",
"<ipython-input-54-6fd4c6570dd1> in <module>()\n",
" 1 Z = np.zeros(10)\n",
" 2 Z.flags.writeable = False\n",
"----> 3 Z[0] = 1\n",
"\n",
"ValueError: assignment destination is read-only\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "98DFC2521652463589FF8DDAF36B08FE",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 44. 将笛卡尔坐标下的一个```10x2```的矩阵转换为极坐标形式(★★☆) \n",
"(**hint**: ```np.sqrt, np.arctan2```)"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"collapsed": true,
"id": "CF88855CE1504CC1BC1C867605DA8BB7",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.random((10,2))\n",
"# X,Y = Z[:,0], Z[:,1]\n",
"# R = np.sqrt(X**2+Y**2)\n",
"# T = np.arctan2(Y,X)\n",
"# print (R)\n",
"# print (T)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "D07B13CEE9B24B9B88165ADF6CBA7401",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 45. 创建一个长度为10的向量，并将向量中最大值替换为1 (★★☆) \n",
"(**提示**: ```argmax```)"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"collapsed": true,
"id": "3AE6B7B7914149238A6A28CD0A8DAA9E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.random(10)\n",
"# Z[Z.argmax()] = 0\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "0F820B0DF2E14655890CD971AE0272D3",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 46. 创建一个结构化数组，并实现 `x` 和 `y` 坐标覆盖 ```[0,1]x[0,1]``` 区域 (★★☆) \n",
"(**提示**: ```np.meshgrid```)"
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {
"collapsed": true,
"id": "7BD9ED6C246544858EB94CB9F785A150",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.zeros((5,5), [('x',float),('y',float)])\n",
"# Z['x'], Z['y'] = np.meshgrid(np.linspace(0,1,5),\n",
"# np.linspace(0,1,5))\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "73EEF9858D8E4A828272CCC7BCE20A43",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 47. 给定两个数组```X```和```Y```，构造Cauchy矩阵C ```(Cij =1/(xi - yj))```\n",
"(**提示**: ```np.subtract.outer```)"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"collapsed": true,
"id": "C9BCA7FFCB8544838CE8DD8524844817",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# X = np.arange(8)\n",
"# Y = X + 0.5\n",
"# C = 1.0 / np.subtract.outer(X, Y)\n",
"# print(np.linalg.det(C))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FC59A059DD094F4BB5CDC4E229958AED",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 48. 打印每个numpy标量类型的最小值和最大值？ (★★☆) \n",
"(**提示**: ```np.iinfo, np.finfo, eps```)"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"collapsed": true,
"id": "F4575981070D41FA8983FB07431CB87A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# for dtype in [np.int8, np.int32, np.int64]:\n",
"# print(np.iinfo(dtype).min)\n",
"# print(np.iinfo(dtype).max)\n",
"\n",
"# for dtype in [np.float32, np.float64]:\n",
"# print(np.finfo(dtype).min)\n",
"# print(np.finfo(dtype).max)\n",
"# print(np.finfo(dtype).eps)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "DF957A2129FB4636A8F47A765DF0F96F",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 49. 如何打印一个数组中的所有数值? (★★☆) \n",
"(**提示**: ```np.set_printoptions```)"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {
"collapsed": true,
"id": "56EA8BE07DE04A0D847D4FC7FD545A76",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# np.set_printoptions(threshold=np.nan)\n",
"# Z = np.zeros((16,16))\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4CDD8B8C9AB94302813674249668C14C",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 50. 给定标量时，如何找到数组中最接近标量的值？(★★☆) \n",
"(**提示**: ```argmin```)"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {
"collapsed": true,
"id": "04BC778A88C14ABF83B1C9B99F9D32BF",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(100)\n",
"# v = np.random.uniform(0,100)\n",
"# index = (np.abs(Z-v)).argmin()\n",
"# print (Z[index])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "B8BDE1CC85E749D4B1F5AAFDC6969810",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 51. 创建一个表示位置```(x,y)```和颜色```(r,g,b)```的结构化数组(★★☆) \n",
"(**提示**: ```dtype```)"
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {
"collapsed": true,
"id": "46DA786D707840318F1B9FDFE16644C1",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.zeros(10, [ ('position', [ ('x', float, 1),\n",
"# ('y', float, 1)]),\n",
"# ('color', [ ('r', float, 1),\n",
"# ('g', float, 1),\n",
"# ('b', float, 1)])])\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "DC2A897ACBBE4659BF4490F0BD2A35C3",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 52. 对一个表示坐标形状为(100,2)的随机向量，找到点与点的距离(★★☆) \n",
"(**提示**: ```np.atleast_2d, T, np.sqrt)```"
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {
"collapsed": true,
"id": "0595F131624F49E6859D0BA252FEA44D",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.random((10,2))\n",
"# X,Y = np.atleast_2d(Z[:,0], Z[:,1])\n",
"# D = np.sqrt( (X-X.T)**2 + (Y-Y.T)**2)\n",
"# print (D)"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {
"collapsed": true,
"id": "AF5E882D646C46148A8E8FF0AA90A0B7",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# # 方法2\n",
"# # Much faster with scipy\n",
"# import scipy\n",
"# # Thanks Gavin Heverly-Coulson (#issue 1)\n",
"# import scipy.spatial\n",
"# D = scipy.spatial.distance.cdist(Z,Z)\n",
"# print (D)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6E021C635941407CB99EF6A4460868D8",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 53. 如何将32位的浮点数(```float```)转换为对应的整数(```integer```)?\n",
"(**提示**: ```astype(copy=False)```)"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {
"collapsed": true,
"id": "F3A776074F42411588D1B8840BD6CE57",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(10, dtype=np.int32)\n",
"# Z = Z.astype(np.float32, copy=False)\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "A89E8C46EA4C4E0C8C27BEB4B808A7F9",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 54. 如何读取以下文件? (★★☆) \n",
"(**提示**: ```np.genfromtxt```)\n",
"```\n",
"1, 2, 3, 4, 5\n",
"6, , , 7, 8\n",
" , , 9,10,11\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "00C8C0828A6B4DE2A052A818919776B2",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"[参考链接](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.genfromtxt.html)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3662D893F84D4B858513A1F791715312",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 55. 对于```numpy```数组，```enumerate```的等价操作是什么？(★★☆) \n",
"(**提示**: ```np.ndenumerate, np.ndindex```)"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {
"collapsed": true,
"id": "36A349A837E64D2381C729EDB4E4A1BB",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(9).reshape(3,3)\n",
"# for index, value in np.ndenumerate(Z):\n",
"# print (index, value)\n",
"# for index in np.ndindex(Z.shape):\n",
"# print (index, Z[index])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "1D801ED8F53849EE81F60F1A5776D82E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 56. 生成一个通用的二维Gaussian-like数组 (★★☆) \n",
"(**提示**: ```np.meshgrid, np.exp```)"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {
"collapsed": true,
"id": "E1271CD7CDF34116B788E66270DA72C6",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# X, Y = np.meshgrid(np.linspace(-1,1,10), np.linspace(-1,1,10))\n",
"# D = np.sqrt(X*X+Y*Y)\n",
"# sigma, mu = 1.0, 0.0\n",
"# G = np.exp(-( (D-mu)**2 / ( 2.0 * sigma**2 ) ) )\n",
"# print (G)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "5C1DE8E188344B098F39502676745D7D",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 57. 对一个二维数组，如何在其内部随机放置p个元素? (★★☆) \n",
"(**提示**: ```np.put, np.random.choice```)"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {
"collapsed": true,
"id": "9E8F022F3F3A421480674F7EAF8C1107",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# n = 10\n",
"# p = 3\n",
"# Z = np.zeros((n,n))\n",
"# np.put(Z, np.random.choice(range(n*n), p, replace=False),1)\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "A42E45EE8E304C1D85385AA71201FBC4",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 58. 减去一个矩阵中的每一行的平均值 (★★☆) \n",
"(**提示**: ```mean(axis=,keepdims=)```)"
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {
"collapsed": true,
"id": "210C23C0A0D143EE85BF270AB24F4DD4",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# X = np.random.rand(5, 10)\n",
"# # Recent versions of numpy\n",
"# Y = X - X.mean(axis=1, keepdims=True)\n",
"# print(Y)"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {
"collapsed": true,
"id": "3371E9CC8B774089B2260A1C7FFDF5BE",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# # 方法2\n",
"# # Older versions of numpy\n",
"# Y = X - X.mean(axis=1).reshape(-1, 1)\n",
"# print (Y)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BFA3974BCF20453E8E00E5BF14BC518C",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 59. 如何通过第n列对一个数组进行排序? (★★☆) \n",
"(**提示**: ```argsort```)"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {
"collapsed": true,
"id": "B7D468144A3A416183BB1D6B14A610B2",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.randint(0,10,(3,3))\n",
"# print (Z)\n",
"# print (Z[Z[:,1].argsort()])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "713E4E4CBCD44A5D83B206C137D9298A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 60. 如何检查一个二维数组是否有空列？(★★☆) \n",
"(**提示**: ```any, ~```)"
]
},
{
"cell_type": "code",
"execution_count": 79,
"metadata": {
"collapsed": true,
"id": "D0E560F6FC584924887B5C25A0B9E8C5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.randint(0,3,(3,10))\n",
"# print ((~Z.any(axis=0)).any())"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FC3FB413C733428F85D2AB6442725294",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 61. 从数组中的给定值中找出最近的值 (★★☆) \n",
"(**提示**: ```np.abs, argmin, flat```)"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {
"collapsed": true,
"id": "6E66FB7429FF4362800B4FB1841A32B9",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.uniform(0,1,10)\n",
"# z = 0.5\n",
"# m = Z.flat[np.abs(Z - z).argmin()]\n",
"# print (m)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "02011498C99B4AF79D366C5CCCCFB38F",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 62. 如何用迭代器(```iterator```)计算两个分别具有形状(1,3)和(3,1)的数组? (★★☆) \n",
"(**提示**: ```np.nditer```)"
]
},
{
"cell_type": "code",
"execution_count": 81,
"metadata": {
"collapsed": true,
"id": "85402397D0104B8A9EDC13F937E5D11B",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# A = np.arange(3).reshape(3,1)\n",
"# B = np.arange(3).reshape(1,3)\n",
"# it = np.nditer([A,B,None])\n",
"# for x,y,z in it: \n",
"# z[...] = x + y\n",
"# print (it.operands[2])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4E73DA4B7DD9411497461196A53C90DE",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 63. 创建一个具有```name```属性的数组类(★★☆) \n",
"(**提示**: ```class```方法)"
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {
"collapsed": true,
"id": "A4FAF12305F14E559772A9AB42221E18",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# class NamedArray(np.ndarray):\n",
"# def __new__(cls, array, name=\"no name\"):\n",
"# obj = np.asarray(array).view(cls)\n",
"# obj.name = name\n",
"# return obj\n",
"# def __array_finalize__(self, obj):\n",
"# if obj is None: return\n",
"# self.info = getattr(obj, 'name', \"no name\")\n",
"\n",
"# Z = NamedArray(np.arange(10), \"range_10\")\n",
"# print (Z.name)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "56B6FBD96064483F83863B10A1630960",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 64. 考虑一个给定的向量，如何对由第二个向量索引的每个元素加1(小心重复的索引)? (★★★) \n",
"(**提示**: ```np.bincount | np.add.at```)"
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {
"collapsed": true,
"id": "B99FB5DF5268466F8E8EED615084EB09",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.ones(10)\n",
"# I = np.random.randint(0,len(Z),20)\n",
"# Z += np.bincount(I, minlength=len(Z))\n",
"# print(Z)"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {
"collapsed": true,
"id": "A7E8FD80E3A443358EF5C0E6CF945660",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# # 方法2\n",
"# np.add.at(Z, I, 1)\n",
"# print(Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "630A718A56DF45C68AC2219FE95D19BB",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 65. 根据索引列表(```I```)，如何将向量(```X```)的元素累加到数组(```F```)? (★★★) \n",
"(**提示**: ```np.bincount```)"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {
"collapsed": true,
"id": "D5017E1D87B3474482F376AB7CE2DFCA",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# X = [1,2,3,4,5,6]\n",
"# I = [1,3,9,3,4,1]\n",
"# F = np.bincount(I,X)\n",
"# print (F)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4A2A3596690B402E80C41EA04CD710AE",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 66. 考虑一个```(dtype=ubyte)``` 的 ```(w,h,3)```图像，计算其唯一颜色的数量(★★★) \n",
"(**提示**: ```np.unique```)"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {
"collapsed": true,
"id": "95A3B6B3C68A42188EB76A502A3C510F",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# w,h = 16,16\n",
"# I = np.random.randint(0,2,(h,w,3)).astype(np.ubyte)\n",
"# #Note that we should compute 256*256 first. \n",
"# #Otherwise numpy will only promote F.dtype to 'uint16' and overfolw will occur\n",
"# F = I[...,0]*(256*256) + I[...,1]*256 +I[...,2]\n",
"# n = len(np.unique(F))\n",
"# print (n)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FEF1B9D441DC416B868659E8ABB02D98",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 67. 考虑一个四维数组，如何一次性计算出最后两个轴(```axis```)的和？ (★★★) \n",
"(**提示**: ```sum(axis=(-2,-1))```)"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {
"collapsed": true,
"id": "C2F3794A1772409EAD83C123C5DDFEEC",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# A = np.random.randint(0,10,(3,4,3,4))\n",
"# # solution by passing a tuple of axes (introduced in numpy 1.7.0)\n",
"# sum = A.sum(axis=(-2,-1))\n",
"# print (sum)"
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {
"collapsed": true,
"id": "A7F12DAF75C240ED91C7FD7BD21EC923",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# # 方法2\n",
"# sum = A.reshape(A.shape[:-2] + (-1,)).sum(axis=-1)\n",
"# print (sum)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "22DA1FE2380649F5897037716C3C3FDB",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 68. 考虑一个一维向量```D```，如何使用相同大小的向量```S```来计算```D```子集的均值？(★★★) \n",
"(**提示**: ```np.bincount```)"
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {
"collapsed": true,
"id": "BEDF3326F7694F1A89F62E88C6A56A76",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# D = np.random.uniform(0,1,100)\n",
"# S = np.random.randint(0,10,100)\n",
"# D_sums = np.bincount(S, weights=D)\n",
"# D_counts = np.bincount(S)\n",
"# D_means = D_sums / D_counts\n",
"# print (D_means)"
]
},
{
"cell_type": "code",
"execution_count": 90,
"metadata": {
"collapsed": true,
"id": "4A7CB0F23BCB41E8828E483652E1A8F0",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# # 方法2\n",
"# import pandas as pd\n",
"# print(pd.Series(D).groupby(S).mean())"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "F53232053DF742718EF3063B7A0FD0EB",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 69. 如何获得点积 ```dot prodcut```的对角线? (★★★) \n",
"(**提示**: ```np.diag```)"
]
},
{
"cell_type": "code",
"execution_count": 91,
"metadata": {
"collapsed": true,
"id": "EBBAFF692F744180A99B6E6F301A8E0D",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# A = np.random.uniform(0,1,(5,5))\n",
"# B = np.random.uniform(0,1,(5,5))\n",
"# # slow version\n",
"# np.diag(np.dot(A, B))"
]
},
{
"cell_type": "code",
"execution_count": 92,
"metadata": {
"collapsed": true,
"id": "084693AF2B1C4F3DAC05E4D0D0343958",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"## 方法2\n",
"# # Fast version\n",
"# np.sum(A * B.T, axis=1)"
]
},
{
"cell_type": "code",
"execution_count": 93,
"metadata": {
"collapsed": true,
"id": "1A9C15379DF9405FB6328AD66511C088",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"## 方法3\n",
"# # Faster version\n",
"# np.einsum(\"ij,ji->i\", A, B)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "48EE054F54744FEC9300AD56BC62C8D7",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 70. 考虑一个向量```[1,2,3,4,5]```,如何建立一个新的向量，在这个新向量中每个值之间有3个连续的零？(★★★) \n",
"(**提示**: ```array[::4]```)"
]
},
{
"cell_type": "code",
"execution_count": 94,
"metadata": {
"collapsed": true,
"id": "1CBB573916834CD18073236E24383F47",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.array([1,2,3,4,5])\n",
"# nz = 3\n",
"# Z0 = np.zeros(len(Z) + (len(Z)-1)*(nz))\n",
"# Z0[::nz+1] = Z\n",
"# print (Z0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "56D0343C2EFA4AA79407D5D219AE9C34",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 71. 考虑一个维度(5,5,3)的数组，如何将其与一个(5,5)的数组相乘？(★★★) \n",
"(**提示**: ```array[:, :, None]```)"
]
},
{
"cell_type": "code",
"execution_count": 95,
"metadata": {
"collapsed": true,
"id": "9D21F03160F041B9A9CFDAC5BFA8283A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# A = np.ones((5,5,3))\n",
"# B = 2*np.ones((5,5))\n",
"# print (A * B[:,:,None])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FF1121B68753430CB7BE9B0C30EE1D32",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 72. 如何对一个数组中任意两行做交换? (★★★) \n",
"(**提示**: ```array[[]] = array[[]]```)"
]
},
{
"cell_type": "code",
"execution_count": 96,
"metadata": {
"collapsed": true,
"id": "3DB1AC9EFA7D4FB48D3E104C567AB7D3",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# A = np.arange(25).reshape(5,5)\n",
"# A[[0,1]] = A[[1,0]]\n",
"# print (A)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2E7011A162D342FF892C94E5B2C82AF0",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 73. 考虑一个可以描述10个三角形的triplets，找到可以分割全部三角形的line segment \n",
"Consider a set of 10 triplets describing 10 triangles (with shared vertices), find the set of unique line segments composing all the triangles (★★★) \n",
"(**提示**: ```repeat, np.roll, np.sort, view, np.unique```)"
]
},
{
"cell_type": "code",
"execution_count": 97,
"metadata": {
"collapsed": true,
"id": "1F68365590154613B7E8011A52625300",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# faces = np.random.randint(0,100,(10,3))\n",
"# F = np.roll(faces.repeat(2,axis=1),-1,axis=1)\n",
"# F = F.reshape(len(F)*3,2)\n",
"# F = np.sort(F,axis=1)\n",
"# G = F.view( dtype=[('p0',F.dtype),('p1',F.dtype)] )\n",
"# G = np.unique(G)\n",
"# print (G)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "C4A2F864E6B24BA8A70FF32ED8CEF305",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 74. 给定一个二进制的数组```C```，如何产生一个数组```A```满足```np.bincount(A)==C```(★★★) \n",
"(**提示**: ```np.repeat```)"
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {
"collapsed": true,
"id": "C3DA4B9685B24058A7DC2E670A1CADCF",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# C = np.bincount([1,1,2,3,4,4,6])\n",
"# A = np.repeat(np.arange(len(C)), C)\n",
"# print (A)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "B12FD13D314349848DCC7E6C8D86DF0F",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 75. 如何通过滑动窗口计算一个数组的平均数? (★★★) \n",
"(**提示**: ```np.cumsum```)"
]
},
{
"cell_type": "code",
"execution_count": 99,
"metadata": {
"collapsed": true,
"id": "BE7A3F46F37B43C9BE869FB5E1AE7C8D",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# def moving_average(a, n=3) :\n",
"# ret = np.cumsum(a, dtype=float)\n",
"# ret[n:] = ret[n:] - ret[:-n]\n",
"# return ret[n - 1:] / n\n",
"# Z = np.arange(20)\n",
"\n",
"# print(moving_average(Z, n=3))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AFB78198A1D4414E8632CB88C305AD8A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 76. Consider a one-dimensional array Z, build a two-dimensional array whose first row is (Z\\[0\\],Z\\[1\\],Z\\[2\\]) and each subsequent row is shifted by 1 (last row should be (Z\\[-3\\],Z\\[-2\\],Z\\[-1\\]) (★★★) \n",
"(**提示**: ```from numpy.lib import stride_tricks```)"
]
},
{
"cell_type": "code",
"execution_count": 100,
"metadata": {
"collapsed": true,
"id": "24F51BFDF35845C6B71FEF2F66A63FFE",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# from numpy.lib import stride_tricks\n",
"\n",
"# def rolling(a, window):\n",
"# shape = (a.size - window + 1, window)\n",
"# strides = (a.itemsize, a.itemsize)\n",
"# return stride_tricks.as_strided(a, shape=shape, strides=strides)\n",
"# Z = rolling(np.arange(10), 3)\n",
"\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "07D09F00B9274F09B1A1A2438EF502E4",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 77. 如何对布尔值取反，或者原位(```in-place```)改变浮点数的符号(```sign```)？(★★★) \n",
"(**提示**: ```np.logical_not, np.negative```)"
]
},
{
"cell_type": "code",
"execution_count": 101,
"metadata": {
"collapsed": true,
"id": "1FF18DB3A6CD407983035E26C7DDC642",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.randint(0,2,100)\n",
"# np.logical_not(Z, out=Z)"
]
},
{
"cell_type": "code",
"execution_count": 102,
"metadata": {
"collapsed": true,
"id": "F2A7772989C9479A84D3281A9BDA4250",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.uniform(-1.0,1.0,100)\n",
"# np.negative(Z, out=Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "F7238C25E1324E59B49A8246E0E1803D",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 78. 考虑两组点集```P0```和```P1```去描述一组线(二维)和一个点```p```,如何计算点```p```到每一条线 i ```(P0[i],P1[i])```的距离？(★★★)"
]
},
{
"cell_type": "code",
"execution_count": 103,
"metadata": {
"collapsed": true,
"id": "2BE011F6ABE94E589F06CD32FD642C78",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# def distance(P0, P1, p):\n",
"# T = P1 - P0\n",
"# L = (T**2).sum(axis=1)\n",
"# U = -((P0[:,0]-p[...,0])*T[:,0] + (P0[:,1]-p[...,1])*T[:,1]) / L\n",
"# U = U.reshape(len(U),1)\n",
"# D = P0 + U*T - p\n",
"# return np.sqrt((D**2).sum(axis=1))\n",
"\n",
"# P0 = np.random.uniform(-10,10,(10,2))\n",
"# P1 = np.random.uniform(-10,10,(10,2))\n",
"# p = np.random.uniform(-10,10,( 1,2))\n",
"\n",
"# print (distance(P0, P1, p))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "313AF7F2B08D483F8DCAA199F0B647E3",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 79.考虑两组点集```P0```和```P1```去描述一组线(二维)和一组点集```P```，如何计算每一个点 ```j(P[j])``` 到每一条线 i ```(P0[i],P1[i]) ```的距离？(★★★)"
]
},
{
"cell_type": "code",
"execution_count": 104,
"metadata": {
"collapsed": true,
"id": "7C553C37C29C4080A48701D6042FDA31",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# # based on distance function from previous question\n",
"# P0 = np.random.uniform(-10, 10, (10,2))\n",
"# P1 = np.random.uniform(-10,10,(10,2))\n",
"# p = np.random.uniform(-10, 10, (10,2))\n",
"# print (np.array([distance(P0,P1,p_i) for p_i in p]))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "405F07374A264727A590D94970B97AE5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 80.Consider an arbitrary array, write a function that extract a subpart with a fixed shape and centered on a given element (pad with a `fill` value when necessary) (★★★) \n",
"(**hint**: minimum, maximum)"
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {
"collapsed": true,
"id": "BAC016239FC347B486DD5AC4DA506AAE",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.randint(0,10,(10,10))\n",
"# shape = (5,5)\n",
"# fill = 0\n",
"# position = (1,1)\n",
"\n",
"# R = np.ones(shape, dtype=Z.dtype)*fill\n",
"# P = np.array(list(position)).astype(int)\n",
"# Rs = np.array(list(R.shape)).astype(int)\n",
"# Zs = np.array(list(Z.shape)).astype(int)\n",
"\n",
"# R_start = np.zeros((len(shape),)).astype(int)\n",
"# R_stop = np.array(list(shape)).astype(int)\n",
"# Z_start = (P-Rs//2)\n",
"# Z_stop = (P+Rs//2)+Rs%2\n",
"\n",
"# R_start = (R_start - np.minimum(Z_start,0)).tolist()\n",
"# Z_start = (np.maximum(Z_start,0)).tolist()\n",
"# R_stop = np.maximum(R_start, (R_stop - np.maximum(Z_stop-Zs,0))).tolist()\n",
"# Z_stop = (np.minimum(Z_stop,Zs)).tolist()\n",
"\n",
"# r = [slice(start,stop) for start,stop in zip(R_start,R_stop)]\n",
"# z = [slice(start,stop) for start,stop in zip(Z_start,Z_stop)]\n",
"# R[r] = Z[z]\n",
"# print (Z)\n",
"# print (R)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "C9E524EE9063410582419C615ED27AA0",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 81. 考虑一个数组```Z = [1,2,3,4,5,6,7,8,9,10,11,12,13,14]```,如何生成一个数组```R = [[1,2,3,4], [2,3,4,5], [3,4,5,6], ...,[11,12,13,14]]```? (★★★) \n",
"(**提示**: ```stride_tricks.as_strided```)"
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {
"collapsed": true,
"id": "43CDF04FE2394915A059DD1BB4C901EE",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(1,15,dtype=np.uint32)\n",
"# R = stride_tricks.as_strided(Z,(11,4),(4,4))\n",
"# print (R)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "E2D036A1A89743EF9AD4C674B94FAD85",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 82. 计算一个矩阵的秩(★★★) \n",
"(**提示**: ```np.linalg.svd```)"
]
},
{
"cell_type": "code",
"execution_count": 107,
"metadata": {
"collapsed": true,
"id": "BCA339C5EA214E1E8E2CD7E83EC987DB",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.uniform(0,1,(10,10))\n",
"# U, S, V = np.linalg.svd(Z) # Singular Value Decomposition\n",
"# rank = np.sum(S > 1e-10)\n",
"# print (rank)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "E25CC326657644A080330F9C5D37FC86",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 83. 如何找到一个数组中出现频率最高的值？ \n",
"(**提示**: ```np.bincount, argmax```)"
]
},
{
"cell_type": "code",
"execution_count": 108,
"metadata": {
"collapsed": true,
"id": "733C7593D0AF41938CA9CC3B456AE6F5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.randint(0,10,50)\n",
"# print (np.bincount(Z).argmax())"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "A07EC615196149998A779CC23A664A7D",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 84. 从一个```10x10```的矩阵中提取出连续的```3x3```区块(★★★) \n",
"(**提示**: ```stride_tricks.as_strided```)"
]
},
{
"cell_type": "code",
"execution_count": 109,
"metadata": {
"collapsed": true,
"id": "C6FF080800EF4CCA86BA7C46C2A0A4CF",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.randint(0,5,(10,10))\n",
"# n = 3\n",
"# i = 1 + (Z.shape[0]-3)\n",
"# j = 1 + (Z.shape[1]-3)\n",
"# C = stride_tricks.as_strided(Z, shape=(i, j, n, n), strides=Z.strides + Z.strides)\n",
"# print (C)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "943C8A7CF29E4CBB98951A553E84EAE4",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 85. 创建一个满足 ```Z[i,j] == Z[j,i]```的子类 (★★★) \n",
"(**提示**: ```class``` 方法)"
]
},
{
"cell_type": "code",
"execution_count": 110,
"metadata": {
"collapsed": true,
"id": "FB5B4EE1E960470485E204AB682E507E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# class Symetric(np.ndarray):\n",
"# def __setitem__(self, index, value):\n",
"# i,j = index\n",
"# super(Symetric, self).__setitem__((i,j), value)\n",
"# super(Symetric, self).__setitem__((j,i), value)\n",
"\n",
"# def symetric(Z):\n",
"# return np.asarray(Z + Z.T - np.diag(Z.diagonal())).view(Symetric)\n",
"\n",
"# S = symetric(np.random.randint(0,10,(5,5)))\n",
"# S[2,3] = 42\n",
"# print (S)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "60BB1B061FDA489D85A87463BB7A7B8D",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 86. 考虑p个 ```nxn``` 矩阵和一组形状为```(n,1)```的向量，如何直接计算p个矩阵的乘积```(n,1)```？(★★★) \n",
"(**提示**: ```np.tensordot```)"
]
},
{
"cell_type": "code",
"execution_count": 111,
"metadata": {
"collapsed": true,
"id": "D6E9B8A3B69E41698447586FCF1E3B76",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# p, n = 10, 20\n",
"# M = np.ones((p,n,n))\n",
"# V = np.ones((p,n,1))\n",
"# S = np.tensordot(M, V, axes=[[0, 2], [0, 1]])\n",
"# print (S)\n",
"# It works, because:\n",
"# M is (p,n,n)\n",
"# V is (p,n,1)\n",
"# Thus, summing over the paired axes 0 and 0 (of M and V independently),\n",
"# and 2 and 1, to remain with a (n,1) vector."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "E298E26CA8FC4D0A87CE17B3C8ED448A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 87. 对于一个```16x16```的数组，如何得到一个区域(```block-sum```)的和(区域大小为```4x4```)? (★★★) \n",
"(**提示**: ```np.add.reduceat```)"
]
},
{
"cell_type": "code",
"execution_count": 112,
"metadata": {
"collapsed": true,
"id": "B2B86B64BD1D4BA081132EFF55494EEF",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.ones((16,16))\n",
"# k = 4\n",
"# S = np.add.reduceat(np.add.reduceat(Z, np.arange(0, Z.shape[0], k), axis=0),\n",
"# np.arange(0, Z.shape[1], k), axis=1)\n",
"# print (S)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "9733DB33A4FE41FA9B7A28BA6D9BA323",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 88. 如何利用```numpy```数组实现Game of Life? (★★★)\n",
"(**提示**: [Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life))"
]
},
{
"cell_type": "code",
"execution_count": 113,
"metadata": {
"collapsed": true,
"id": "B2F6FEF7398549F68F4281BC20B41165",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# def iterate(Z):\n",
"# # Count neighbours\n",
"# N = (Z[0:-2,0:-2] + Z[0:-2,1:-1] + Z[0:-2,2:] +\n",
"# Z[1:-1,0:-2] + Z[1:-1,2:] +\n",
"# Z[2: ,0:-2] + Z[2: ,1:-1] + Z[2: ,2:])\n",
"\n",
"# # Apply rules\n",
"# birth = (N==3) & (Z[1:-1,1:-1]==0)\n",
"# survive = ((N==2) | (N==3)) & (Z[1:-1,1:-1]==1)\n",
"# Z[...] = 0\n",
"# Z[1:-1,1:-1][birth | survive] = 1\n",
"# return Z\n",
"\n",
"# Z = np.random.randint(0,2,(50,50))\n",
"# for i in range(100): Z = iterate(Z)\n",
"# print (Z)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "05F350A2ECBF46928879CD5EC729C4C7",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 89. 如何找到一个数组的第n个最大值? (★★★) \n",
"(**提示**: ```np.argsort | np.argpartition```)"
]
},
{
"cell_type": "code",
"execution_count": 114,
"metadata": {
"collapsed": true,
"id": "AD514F23AA6A499D8FA7065841F72613",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.arange(10000)\n",
"# np.random.shuffle(Z)\n",
"# n = 5\n",
"\n",
"# # Slow\n",
"# print (Z[np.argsort(Z)[-n:]])"
]
},
{
"cell_type": "code",
"execution_count": 115,
"metadata": {
"collapsed": true,
"id": "203F24EA60A44E2580965FCFE02C757D",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# # 方法2\n",
"# # Fast\n",
"# print (Z[np.argpartition(-Z,n)[:n]])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "A6B0BF5FA1EC4CAF9F77C9C2F503107A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 90. 给定任意个数向量，创建笛卡尔积(每一个元素的每一种组合)(★★★) \n",
"(**提示**: ```np.indices```)"
]
},
{
"cell_type": "code",
"execution_count": 116,
"metadata": {
"collapsed": true,
"id": "46D4E9E4169541228B2C40FF1CDBFA12",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# def cartesian(arrays):\n",
"# arrays = [np.asarray(a) for a in arrays]\n",
"# shape = (len(x) for x in arrays)\n",
"\n",
"# ix = np.indices(shape, dtype=int)\n",
"# ix = ix.reshape(len(arrays), -1).T\n",
"\n",
"# for n, arr in enumerate(arrays):\n",
"# ix[:, n] = arrays[n][ix[:, n]]\n",
"\n",
"# return ix\n",
"\n",
"# print (cartesian(([1, 2, 3], [4, 5], [6, 7])))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3D5B5652447848408AE38668828F97C9",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 91. 如何从一个正常数组创建记录数组(```record array```)? (★★★) \n",
"(**提示**: ```np.core.records.fromarrays```)"
]
},
{
"cell_type": "code",
"execution_count": 117,
"metadata": {
"collapsed": true,
"id": "82BEB0A109B149429DDC53232F28D63A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.array([(\"Hello\", 2.5, 3),\n",
"# (\"World\", 3.6, 2)])\n",
"# R = np.core.records.fromarrays(Z.T, \n",
"# names='col1, col2, col3',\n",
"# formats = 'S8, f8, i8')\n",
"# print (R)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "D60D5195C1CA4ACE87B2B82D8C21D606",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 92. 考虑一个大向量```Z```, 用三种不同的方法计算它的立方(★★★) \n",
"(**提示**: ```np.power, \\*, np.einsum```)"
]
},
{
"cell_type": "code",
"execution_count": 118,
"metadata": {
"collapsed": true,
"id": "8519DE17751C4C6B859AEB7A94616D4C",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# x = np.random.rand()\n",
"# np.power(x,3)"
]
},
{
"cell_type": "code",
"execution_count": 119,
"metadata": {
"collapsed": true,
"id": "023FFA04A61143878DC019D3475C847B",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"## 方法2\n",
"# x*x*x"
]
},
{
"cell_type": "code",
"execution_count": 120,
"metadata": {
"collapsed": true,
"id": "7F81104DAA2144368256477522F8E454",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"## 方法3\n",
"# np.einsum('i,i,i->i',x,x,x)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4D83EC574DF24D0F8DE19E9A91F096A4",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 93. 考虑两个形状分别为```(8,3)``` 和```(2,2)```的数组```A```和```B```. 如何在数组```A```中找到满足包含```B```中元素的行？(不考虑```B```中每行元素顺序)？ (★★★) \n",
"(**提示**: ```np.where```)"
]
},
{
"cell_type": "code",
"execution_count": 121,
"metadata": {
"collapsed": true,
"id": "06950269DCDF40E384834AE6F7D9D57E",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# A = np.random.randint(0,5,(8,3))\n",
"# B = np.random.randint(0,5,(2,2))\n",
"\n",
"# C = (A[..., np.newaxis, np.newaxis] == B)\n",
"# rows = np.where(C.any((3,1)).all(1))[0]\n",
"# print (rows)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "50B173E09BE44D7B93B901D9915605C5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 94. 考虑一个```10x3```的矩阵，分解出有不全相同值的行 (如 ```[2,2,3]```) (★★★)"
]
},
{
"cell_type": "code",
"execution_count": 122,
"metadata": {
"collapsed": true,
"id": "67B07B2780C84116B8B3E114AA3F5D92",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.randint(0,5,(10,3))\n",
"# print (Z)\n",
"\n",
"# # solution for arrays of all dtypes (including string arrays and record arrays)\n",
"# E = np.all(Z[:,1:] == Z[:,:-1], axis=1)\n",
"# U = Z[~E]\n",
"# print (U)"
]
},
{
"cell_type": "code",
"execution_count": 123,
"metadata": {
"collapsed": true,
"id": "839AFE04281D430F84C10A037AEF405C",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# # 方法2\n",
"# # soluiton for numerical arrays only, will work for any number of columns in Z\n",
"# U = Z[Z.max(axis=1) != Z.min(axis=1),:]\n",
"# print (U)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3C438C79FF2442C18959B015D50B0382",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 95. 将一个整数向量转换为matrix binary的表现形式 (★★★) \n",
"(**提示**: ```np.unpackbits```)"
]
},
{
"cell_type": "code",
"execution_count": 124,
"metadata": {
"collapsed": true,
"id": "646F659946404BDA9AFFE725EA9E4018",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# I = np.array([0, 1, 2, 3, 15, 16, 32, 64, 128])\n",
"# B = ((I.reshape(-1,1) & (2**np.arange(8))) != 0).astype(int)\n",
"# print(B[:,::-1])"
]
},
{
"cell_type": "code",
"execution_count": 125,
"metadata": {
"collapsed": true,
"id": "067120D1D7034D9F817F06128D79E9E9",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# # 方法2\n",
"# print (np.unpackbits(I[:, np.newaxis], axis=1))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6B62627DE43347D29A80C9B864A53DDA",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 96. 给定一个二维数组，如何提取出唯一的(```unique```)行?(★★★) \n",
"(**提示**: ```np.ascontiguousarray```)"
]
},
{
"cell_type": "code",
"execution_count": 126,
"metadata": {
"collapsed": true,
"id": "9924218AF0644D8F93B01208B6807F03",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# Z = np.random.randint(0,2,(6,3))\n",
"# T = np.ascontiguousarray(Z).view(np.dtype((np.void, Z.dtype.itemsize * Z.shape[1])))\n",
"# _, idx = np.unique(T, return_index=True)\n",
"# uZ = Z[idx]\n",
"# print (uZ)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "5A3738CBA4A349508E7C9F22B5F7166A",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 97. 考虑两个向量```A```和```B```，写出用```einsum```等式对应的```inner, outer, sum, mul```函数(★★★) \n",
"(**提示**: [```np.einsum```](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.einsum.html))"
]
},
{
"cell_type": "code",
"execution_count": 127,
"metadata": {
"collapsed": true,
"id": "8E01F6B983C2426D9217504C83EEE486",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# A = np.random.uniform(0,1,10)\n",
"# B = np.random.uniform(0,1,10)\n",
"# print ('sum')\n",
"# print (np.einsum('i->', A))# np.sum(A)"
]
},
{
"cell_type": "code",
"execution_count": 128,
"metadata": {
"collapsed": true,
"id": "69115798B9A044258DF261C172A4458B",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print ('A * B')\n",
"# print (np.einsum('i,i->i', A, B)) # A * B"
]
},
{
"cell_type": "code",
"execution_count": 129,
"metadata": {
"collapsed": true,
"id": "02C2196DF276469E82B5F6EA24340250",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print ('inner')\n",
"# print (np.einsum('i,i', A, B)) # np.inner(A, B)"
]
},
{
"cell_type": "code",
"execution_count": 130,
"metadata": {
"collapsed": true,
"id": "DB99E8D722E442A89B4D782003EE53F6",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# print ('outer')\n",
"# print (np.einsum('i,j->ij', A, B)) # np.outer(A, B)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "85C64AA83A824194816B708D36AB7E69",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 98. 考虑一个由两个向量描述的路径```(X,Y)```，如何用等距样例(```equidistant samples```)对其进行采样(```sample```)? (★★★) \n",
"Considering a path described by two vectors (X,Y), how to sample it using equidistant samples \n",
"(**提示**: ```np.cumsum, np.interp```)"
]
},
{
"cell_type": "code",
"execution_count": 131,
"metadata": {
"collapsed": true,
"id": "B2CEA801F0164EEA854FBD8F684CA507",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# phi = np.arange(0, 10*np.pi, 0.1)\n",
"# a = 1\n",
"# x = a*phi*np.cos(phi)\n",
"# y = a*phi*np.sin(phi)\n",
"\n",
"# dr = (np.diff(x)**2 + np.diff(y)**2)**.5 # segment lengths\n",
"# r = np.zeros_like(x)\n",
"# r[1:] = np.cumsum(dr) # integrate path\n",
"# r_int = np.linspace(0, r.max(), 200) # regular spaced path\n",
"# x_int = np.interp(r_int, r, x) # integrate path\n",
"# y_int = np.interp(r_int, r, y)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "D5D0E40627A4435184C3813B775A14E5",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 99. Given an integer n and a 2D array X, select from X the rows which can be interpreted as draws from a multinomial distribution with n degrees, i.e., the rows which only contain integers and which sum to n. (★★★) \n",
"(**提示**: ```np.logical_and.reduce, np.mod```)\n"
]
},
{
"cell_type": "code",
"execution_count": 132,
"metadata": {
"collapsed": true,
"id": "1C245E3CFF7D4EFF9913B886A0E8F7DB",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# X = np.asarray([[1.0, 0.0, 3.0, 8.0],\n",
"# [2.0, 0.0, 1.0, 1.0],\n",
"# [1.5, 2.5, 1.0, 0.0]])\n",
"# n = 4\n",
"# M = np.logical_and.reduce(np.mod(X, 1) == 0, axis=-1)\n",
"# M &= (X.sum(axis=-1) == n)\n",
"# print (X[M])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4A31C1F39DE44234BAF2F12720FEE07D",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"#### 100. 对于一个一维数组```X```，计算它boostrapped之后的95%置信区间的平均值。\n",
"(Compute bootstrapped 95% confidence intervals for the mean of a 1D array X，i.e. resample the elements of an array with replacement N times, compute the mean of each sample, and then compute percentiles over the means). (★★★) \n",
"(**提示**: ```np.percentile```)"
]
},
{
"cell_type": "code",
"execution_count": 133,
"metadata": {
"collapsed": true,
"id": "DFF4185E7EF1432D87EE695C4A972C39",
"jupyter": {},
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"outputs": [],
"source": [
"# X = np.random.randn(100) # random 1D array\n",
"# N = 1000 # number of bootstrap samples\n",
"# idx = np.random.randint(0, X.size, (N, X.size))\n",
"# means = X[idx].mean(axis=1)\n",
"# confint = np.percentile(means, [2.5, 97.5])\n",
"# print (confint)"
]
}
],
"metadata": {
"hide_input": false,
"kernelspec": {
"display_name": "Python 3",
"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.5.2"
},
"toc": {
"nav_menu": {},
"number_sections": false,
"sideBar": true,
"skip_h1_title": false,
"toc_cell": false,
"toc_position": {},
"toc_section_display": "block",
"toc_window_display": true
}
},
"nbformat": 4,
"nbformat_minor": 2
}
