组队学习资料
This commit is contained in:
hanhuijin
@@ -1,148 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 常量\n",
|
||||
"\n",
|
||||
"## numpy.nan\n",
|
||||
"\n",
|
||||
"- 表示空值。\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"nan = NaN = NAN\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】两个`numpy.nan`是不相等的。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"print(np.nan == np.nan) # False\n",
|
||||
"print(np.nan != np.nan) # True\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.isnan(x, *args, **kwargs)` Test element-wise for NaN and return result as a boolean array.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 1, 8, np.nan, 10])\n",
|
||||
"print(x)\n",
|
||||
"# [ 1. 1. 8. nan 10.]\n",
|
||||
"\n",
|
||||
"y = np.isnan(x)\n",
|
||||
"print(y)\n",
|
||||
"# [False False False True False]\n",
|
||||
"\n",
|
||||
"z = np.count_nonzero(y)\n",
|
||||
"print(z) # 1\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## numpy.inf\n",
|
||||
"- 表示正无穷大。\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"Inf = inf = infty = Infinity = PINF\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"## numpy.pi\n",
|
||||
"\n",
|
||||
"- 表示圆周率\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"pi = 3.1415926535897932384626433...\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"## numpy.e\n",
|
||||
"\n",
|
||||
"- 表示自然常数\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"e = 2.71828182845904523536028747135266249775724709369995...\n",
|
||||
"```\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.6.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,250 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 数据类型\n",
|
||||
"\n",
|
||||
"## 常见数据类型\n",
|
||||
"\n",
|
||||
"Python 原生的数据类型相对较少， bool、int、float、str等。这在不需要关心数据在计算机中表示的所有方式的应用中是方便的。然而，对于科学计算，通常需要更多的控制。为了加以区分 numpy 在这些类型名称末尾都加了“_”。\n",
|
||||
"\n",
|
||||
"下表列举了常用 numpy 基本类型。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"类型 | 备注 | 说明 \n",
|
||||
"---|---|---\n",
|
||||
"bool_ = bool8 | 8位 | 布尔类型\n",
|
||||
"int8 = byte | 8位 | 整型\n",
|
||||
"int16 = short |\t16位| 整型\n",
|
||||
"int32 = intc | 32位| 整型\n",
|
||||
"int_ = int64 = long = int0 = intp | 64位| 整型\n",
|
||||
"uint8 = ubyte |8位 | 无符号整型\n",
|
||||
"uint16 = ushort|16位| 无符号整型\n",
|
||||
"uint32 = uintc|32位| 无符号整型\n",
|
||||
"uint64 = uintp = uint0 = uint| 64位| 无符号整型\n",
|
||||
"float16 = half|16位 | 浮点型\n",
|
||||
"float32 = single| 32位| 浮点型\n",
|
||||
"float_ = float64 = double| 64位| 浮点型\n",
|
||||
"str_ = unicode_ = str0 = unicode| |Unicode 字符串\n",
|
||||
"datetime64| |日期时间类型\n",
|
||||
"timedelta64| |表示两个时间之间的间隔\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 创建数据类型\n",
|
||||
"\n",
|
||||
"numpy 的数值类型实际上是 dtype 对象的实例。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"class dtype(object):\n",
|
||||
" def __init__(self, obj, align=False, copy=False):\n",
|
||||
" pass\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"每个内建类型都有一个唯一定义它的字符代码，如下：\n",
|
||||
"\n",
|
||||
"字符 | \t对应类型|备注\n",
|
||||
"---|---|---\n",
|
||||
"b\t|boolean | 'b1'\n",
|
||||
"i\t|signed integer | 'i1', 'i2', 'i4', 'i8'\n",
|
||||
"u\t|unsigned integer | 'u1', 'u2' ,'u4' ,'u8'\n",
|
||||
"f\t|floating-point | 'f2', 'f4', 'f8'\n",
|
||||
"c\t|complex floating-point |\n",
|
||||
"m\t|timedelta64 |表示两个时间之间的间隔\n",
|
||||
"M\t|datetime64 |日期时间类型\n",
|
||||
"O\t|object |\n",
|
||||
"S\t|(byte-)string | S3表示长度为3的字符串\n",
|
||||
"U\t|Unicode | Unicode 字符串\n",
|
||||
"V\t|void\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.dtype('b1')\n",
|
||||
"print(a.type) # <class 'numpy.bool_'>\n",
|
||||
"print(a.itemsize) # 1\n",
|
||||
"\n",
|
||||
"a = np.dtype('i1')\n",
|
||||
"print(a.type) # <class 'numpy.int8'>\n",
|
||||
"print(a.itemsize) # 1\n",
|
||||
"a = np.dtype('i2')\n",
|
||||
"print(a.type) # <class 'numpy.int16'>\n",
|
||||
"print(a.itemsize) # 2\n",
|
||||
"a = np.dtype('i4')\n",
|
||||
"print(a.type) # <class 'numpy.int32'>\n",
|
||||
"print(a.itemsize) # 4\n",
|
||||
"a = np.dtype('i8')\n",
|
||||
"print(a.type) # <class 'numpy.int64'>\n",
|
||||
"print(a.itemsize) # 8\n",
|
||||
"\n",
|
||||
"a = np.dtype('u1')\n",
|
||||
"print(a.type) # <class 'numpy.uint8'>\n",
|
||||
"print(a.itemsize) # 1\n",
|
||||
"a = np.dtype('u2')\n",
|
||||
"print(a.type) # <class 'numpy.uint16'>\n",
|
||||
"print(a.itemsize) # 2\n",
|
||||
"a = np.dtype('u4')\n",
|
||||
"print(a.type) # <class 'numpy.uint32'>\n",
|
||||
"print(a.itemsize) # 4\n",
|
||||
"a = np.dtype('u8')\n",
|
||||
"print(a.type) # <class 'numpy.uint64'>\n",
|
||||
"print(a.itemsize) # 8\n",
|
||||
"\n",
|
||||
"a = np.dtype('f2')\n",
|
||||
"print(a.type) # <class 'numpy.float16'>\n",
|
||||
"print(a.itemsize) # 2\n",
|
||||
"a = np.dtype('f4')\n",
|
||||
"print(a.type) # <class 'numpy.float32'>\n",
|
||||
"print(a.itemsize) # 4\n",
|
||||
"a = np.dtype('f8')\n",
|
||||
"print(a.type) # <class 'numpy.float64'>\n",
|
||||
"print(a.itemsize) # 8\n",
|
||||
"\n",
|
||||
"a = np.dtype('S')\n",
|
||||
"print(a.type) # <class 'numpy.bytes_'>\n",
|
||||
"print(a.itemsize) # 0\n",
|
||||
"a = np.dtype('S3')\n",
|
||||
"print(a.type) # <class 'numpy.bytes_'>\n",
|
||||
"print(a.itemsize) # 3\n",
|
||||
"\n",
|
||||
"a = np.dtype('U3')\n",
|
||||
"print(a.type) # <class 'numpy.str_'>\n",
|
||||
"print(a.itemsize) # 12\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"## 数据类型信息\n",
|
||||
"\n",
|
||||
"Python 的浮点数通常是64位浮点数，几乎等同于 `np.float64`。\n",
|
||||
"\n",
|
||||
"NumPy和Python整数类型的行为在整数溢出方面存在显着差异，与 NumPy 不同，Python 的`int` 是灵活的。这意味着Python整数可以扩展以容纳任何整数并且不会溢出。\n",
|
||||
"\n",
|
||||
"Machine limits for integer types.\n",
|
||||
"```python\n",
|
||||
"class iinfo(object):\n",
|
||||
" def __init__(self, int_type):\n",
|
||||
" pass\n",
|
||||
" def min(self):\n",
|
||||
" pass\n",
|
||||
" def max(self):\n",
|
||||
" pass\n",
|
||||
"```\n",
|
||||
"【例】\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"ii16 = np.iinfo(np.int16)\n",
|
||||
"print(ii16.min) # -32768\n",
|
||||
"print(ii16.max) # 32767\n",
|
||||
"\n",
|
||||
"ii32 = np.iinfo(np.int32)\n",
|
||||
"print(ii32.min) # -2147483648\n",
|
||||
"print(ii32.max) # 2147483647\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"Machine limits for floating point types.\n",
|
||||
"```python\n",
|
||||
"class finfo(object):\n",
|
||||
" def _init(self, dtype):\n",
|
||||
"```\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"ff16 = np.finfo(np.float16)\n",
|
||||
"print(ff16.bits) # 16\n",
|
||||
"print(ff16.min) # -65500.0\n",
|
||||
"print(ff16.max) # 65500.0\n",
|
||||
"print(ff16.eps) # 0.000977\n",
|
||||
"\n",
|
||||
"ff32 = np.finfo(np.float32)\n",
|
||||
"print(ff32.bits) # 32\n",
|
||||
"print(ff32.min) # -3.4028235e+38\n",
|
||||
"print(ff32.max) # 3.4028235e+38\n",
|
||||
"print(ff32.eps) # 1.1920929e-07\n",
|
||||
"```\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.6.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {
|
||||
"height": "calc(100% - 180px)",
|
||||
"left": "10px",
|
||||
"top": "150px",
|
||||
"width": "218.2px"
|
||||
},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,356 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 时间日期和时间增量\n",
|
||||
"\n",
|
||||
"## datetime64 基础\n",
|
||||
"\n",
|
||||
"在 numpy 中，我们很方便的将字符串转换成时间日期类型 `datetime64`（`datetime` 已被 python 包含的日期时间库所占用）。\n",
|
||||
"\n",
|
||||
"`datatime64`是带单位的日期时间类型，其单位如下：\n",
|
||||
"\n",
|
||||
"日期单位 | 代码含义|时间单位 | 代码含义\n",
|
||||
":---:|:---:|:---:|:---:\n",
|
||||
"Y | 年 |h | 小时\n",
|
||||
"M | 月 |m | 分钟\n",
|
||||
"W | 周 |s | 秒\n",
|
||||
"D | 天 |ms | 毫秒\n",
|
||||
"- | - |us | 微秒\n",
|
||||
"- | - |ns | 纳秒\n",
|
||||
"- | - |ps | 皮秒\n",
|
||||
"- | - |fs | 飞秒\n",
|
||||
"- | - |as | 阿托秒\n",
|
||||
"\n",
|
||||
"注意：\n",
|
||||
"- 1秒 = 1000 毫秒（milliseconds）\n",
|
||||
"- 1毫秒 = 1000 微秒（microseconds）\n",
|
||||
"\n",
|
||||
"【例】从字符串创建 datetime64 类型时，默认情况下，numpy 会根据字符串自动选择对应的单位。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.datetime64('2020-03-01')\n",
|
||||
"print(a, a.dtype) # 2020-03-01 datetime64[D]\n",
|
||||
"\n",
|
||||
"a = np.datetime64('2020-03')\n",
|
||||
"print(a, a.dtype) # 2020-03 datetime64[M]\n",
|
||||
"\n",
|
||||
"a = np.datetime64('2020-03-08 20:00:05')\n",
|
||||
"print(a, a.dtype) # 2020-03-08T20:00:05 datetime64[s]\n",
|
||||
"\n",
|
||||
"a = np.datetime64('2020-03-08 20:00')\n",
|
||||
"print(a, a.dtype) # 2020-03-08T20:00 datetime64[m]\n",
|
||||
"\n",
|
||||
"a = np.datetime64('2020-03-08 20')\n",
|
||||
"print(a, a.dtype) # 2020-03-08T20 datetime64[h]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】从字符串创建 datetime64 类型时，可以强制指定使用的单位。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.datetime64('2020-03', 'D')\n",
|
||||
"print(a, a.dtype) # 2020-03-01 datetime64[D]\n",
|
||||
"\n",
|
||||
"a = np.datetime64('2020-03', 'Y')\n",
|
||||
"print(a, a.dtype) # 2020 datetime64[Y]\n",
|
||||
"\n",
|
||||
"print(np.datetime64('2020-03') == np.datetime64('2020-03-01')) # True\n",
|
||||
"print(np.datetime64('2020-03') == np.datetime64('2020-03-02')) #False\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"由上例可以看出，2019-03 和 2019-03-01 所表示的其实是同一个时间。\n",
|
||||
"事实上，如果两个 datetime64 对象具有不同的单位，它们可能仍然代表相同的时刻。并且从较大的单位（如月份）转换为较小的单位（如天数）是安全的。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】从字符串创建 datetime64 数组时，如果单位不统一，则一律转化成其中最小的单位。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.array(['2020-03', '2020-03-08', '2020-03-08 20:00'], dtype='datetime64')\n",
|
||||
"print(a, a.dtype)\n",
|
||||
"# ['2020-03-01T00:00' '2020-03-08T00:00' '2020-03-08T20:00'] datetime64[m]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】使用`arange()`创建 datetime64 数组，用于生成日期范围。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.arange('2020-08-01', '2020-08-10', dtype=np.datetime64)\n",
|
||||
"print(a)\n",
|
||||
"# ['2020-08-01' '2020-08-02' '2020-08-03' '2020-08-04' '2020-08-05'\n",
|
||||
"# '2020-08-06' '2020-08-07' '2020-08-08' '2020-08-09']\n",
|
||||
"print(a.dtype) # datetime64[D]\n",
|
||||
"\n",
|
||||
"a = np.arange('2020-08-01 20:00', '2020-08-10', dtype=np.datetime64)\n",
|
||||
"print(a)\n",
|
||||
"# ['2020-08-01T20:00' '2020-08-01T20:01' '2020-08-01T20:02' ...\n",
|
||||
"# '2020-08-09T23:57' '2020-08-09T23:58' '2020-08-09T23:59']\n",
|
||||
"print(a.dtype) # datetime64[m]\n",
|
||||
"\n",
|
||||
"a = np.arange('2020-05', '2020-12', dtype=np.datetime64)\n",
|
||||
"print(a)\n",
|
||||
"# ['2020-05' '2020-06' '2020-07' '2020-08' '2020-09' '2020-10' '2020-11']\n",
|
||||
"print(a.dtype) # datetime64[M]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"## datetime64 和 timedelta64 运算\n",
|
||||
"\n",
|
||||
"【例】timedelta64 表示两个 datetime64 之间的差。timedelta64 也是带单位的，并且和相减运算中的两个 datetime64 中的较小的单位保持一致。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.datetime64('2020-03-08') - np.datetime64('2020-03-07')\n",
|
||||
"b = np.datetime64('2020-03-08') - np.datetime64('202-03-07 08:00')\n",
|
||||
"c = np.datetime64('2020-03-08') - np.datetime64('2020-03-07 23:00', 'D')\n",
|
||||
"\n",
|
||||
"print(a, a.dtype) # 1 days timedelta64[D]\n",
|
||||
"print(b, b.dtype) # 956178240 minutes timedelta64[m]\n",
|
||||
"print(c, c.dtype) # 1 days timedelta64[D]\n",
|
||||
"\n",
|
||||
"a = np.datetime64('2020-03') + np.timedelta64(20, 'D')\n",
|
||||
"b = np.datetime64('2020-06-15 00:00') + np.timedelta64(12, 'h')\n",
|
||||
"print(a, a.dtype) # 2020-03-21 datetime64[D]\n",
|
||||
"print(b, b.dtype) # 2020-06-15T12:00 datetime64[m]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】生成 timedelta64时，要注意年（'Y'）和月（'M'）这两个单位无法和其它单位进行运算（一年有几天？一个月有几个小时？这些都是不确定的）。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.timedelta64(1, 'Y')\n",
|
||||
"b = np.timedelta64(a, 'M')\n",
|
||||
"print(a) # 1 years\n",
|
||||
"print(b) # 12 months\n",
|
||||
"\n",
|
||||
"c = np.timedelta64(1, 'h')\n",
|
||||
"d = np.timedelta64(c, 'm')\n",
|
||||
"print(c) # 1 hours\n",
|
||||
"print(d) # 60 minutes\n",
|
||||
"\n",
|
||||
"print(np.timedelta64(a, 'D'))\n",
|
||||
"# TypeError: Cannot cast NumPy timedelta64 scalar from metadata [Y] to [D] according to the rule 'same_kind'\n",
|
||||
"\n",
|
||||
"print(np.timedelta64(b, 'D'))\n",
|
||||
"# TypeError: Cannot cast NumPy timedelta64 scalar from metadata [M] to [D] according to the rule 'same_kind'\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】timedelta64 的运算。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.timedelta64(1, 'Y')\n",
|
||||
"b = np.timedelta64(6, 'M')\n",
|
||||
"c = np.timedelta64(1, 'W')\n",
|
||||
"d = np.timedelta64(1, 'D')\n",
|
||||
"e = np.timedelta64(10, 'D')\n",
|
||||
"\n",
|
||||
"print(a) # 1 years\n",
|
||||
"print(b) # 6 months\n",
|
||||
"print(a + b) # 18 months\n",
|
||||
"print(a - b) # 6 months\n",
|
||||
"print(2 * a) # 2 years\n",
|
||||
"print(a / b) # 2.0\n",
|
||||
"print(c / d) # 7.0\n",
|
||||
"print(c % e) # 7 days\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】numpy.datetime64 与 datetime.datetime 相互转换\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"import datetime\n",
|
||||
"\n",
|
||||
"dt = datetime.datetime(year=2020, month=6, day=1, hour=20, minute=5, second=30)\n",
|
||||
"dt64 = np.datetime64(dt, 's')\n",
|
||||
"print(dt64, dt64.dtype)\n",
|
||||
"# 2020-06-01T20:05:30 datetime64[s]\n",
|
||||
"\n",
|
||||
"dt2 = dt64.astype(datetime.datetime)\n",
|
||||
"print(dt2, type(dt2))\n",
|
||||
"# 2020-06-01 20:05:30 <class 'datetime.datetime'>\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"## datetime64 的应用\n",
|
||||
"\n",
|
||||
"为了允许在只有一周中某些日子有效的上下文中使用日期时间，NumPy包含一组“busday”（工作日）功能。\n",
|
||||
"\n",
|
||||
"- `numpy.busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)` First adjusts the date to fall on a valid day according to the roll rule, then applies offsets to the given dates counted in valid days.\n",
|
||||
"\n",
|
||||
"参数`roll`：{'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}\n",
|
||||
"- 'raise' means to raise an exception for an invalid day.\n",
|
||||
"- 'nat' means to return a NaT (not-a-time) for an invalid day.\n",
|
||||
"- 'forward' and 'following' mean to take the first valid day later in time.\n",
|
||||
"- 'backward' and 'preceding' mean to take the first valid day earlier in time.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】将指定的偏移量应用于工作日，单位天（'D'）。计算下一个工作日，如果当前日期为非工作日，默认报错。可以指定 `forward` 或 `backward` 规则来避免报错。（一个是向前取第一个有效的工作日，一个是向后取第一个有效的工作日）\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"# 2020-07-10 星期五\n",
|
||||
"a = np.busday_offset('2020-07-10', offsets=1)\n",
|
||||
"print(a) # 2020-07-13\n",
|
||||
"\n",
|
||||
"a = np.busday_offset('2020-07-11', offsets=1)\n",
|
||||
"print(a)\n",
|
||||
"# ValueError: Non-business day date in busday_offset\n",
|
||||
"\n",
|
||||
"a = np.busday_offset('2020-07-11', offsets=0, roll='forward')\n",
|
||||
"b = np.busday_offset('2020-07-11', offsets=0, roll='backward')\n",
|
||||
"print(a) # 2020-07-13\n",
|
||||
"print(b) # 2020-07-10\n",
|
||||
"\n",
|
||||
"a = np.busday_offset('2020-07-11', offsets=1, roll='forward')\n",
|
||||
"b = np.busday_offset('2020-07-11', offsets=1, roll='backward')\n",
|
||||
"print(a) # 2020-07-14\n",
|
||||
"print(b) # 2020-07-13\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"可以指定偏移量为 0 来获取当前日期向前或向后最近的工作日，当然，如果当前日期本身就是工作日，则直接返回当前日期。\n",
|
||||
"\n",
|
||||
"- `numpy.is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)` Calculates which of the given dates are valid days, and which are not.\n",
|
||||
"\n",
|
||||
"【例】返回指定日期是否是工作日。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"# 2020-07-10 星期五\n",
|
||||
"a = np.is_busday('2020-07-10')\n",
|
||||
"b = np.is_busday('2020-07-11')\n",
|
||||
"print(a) # True\n",
|
||||
"print(b) # False\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】统计一个 `datetime64[D]` 数组中的工作日天数。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"# 2020-07-10 星期五\n",
|
||||
"begindates = np.datetime64('2020-07-10')\n",
|
||||
"enddates = np.datetime64('2020-07-20')\n",
|
||||
"a = np.arange(begindates, enddates, dtype='datetime64')\n",
|
||||
"b = np.count_nonzero(np.is_busday(a))\n",
|
||||
"print(a)\n",
|
||||
"# ['2020-07-10' '2020-07-11' '2020-07-12' '2020-07-13' '2020-07-14'\n",
|
||||
"# '2020-07-15' '2020-07-16' '2020-07-17' '2020-07-18' '2020-07-19']\n",
|
||||
"print(b) # 6\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】自定义周掩码值，即指定一周中哪些星期是工作日。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"# 2020-07-10 星期五\n",
|
||||
"a = np.is_busday('2020-07-10', weekmask=[1, 1, 1, 1, 1, 0, 0])\n",
|
||||
"b = np.is_busday('2020-07-10', weekmask=[1, 1, 1, 1, 0, 0, 1])\n",
|
||||
"print(a) # True\n",
|
||||
"print(b) # False\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)`Counts the number of valid days between `begindates` and `enddates`, not including the day of `enddates`.\n",
|
||||
"\n",
|
||||
"【例】返回两个日期之间的工作日数量。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"# 2020-07-10 星期五\n",
|
||||
"begindates = np.datetime64('2020-07-10')\n",
|
||||
"enddates = np.datetime64('2020-07-20')\n",
|
||||
"a = np.busday_count(begindates, enddates)\n",
|
||||
"b = np.busday_count(enddates, begindates)\n",
|
||||
"print(a) # 6\n",
|
||||
"print(b) # -6\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"<b>参考图文</b>\n",
|
||||
"\n",
|
||||
"- https://www.jianshu.com/p/336cd77d9914\n",
|
||||
"- https://www.cnblogs.com/gl1573/p/10549547.html#h2datetime64\n",
|
||||
"- https://www.numpy.org.cn/reference/arrays/datetime.html#%E6%97%A5%E6%9C%9F%E6%97%B6%E9%97%B4%E5%8D%95%E4%BD%8D\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.6.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,617 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n",
|
||||
"[toc]\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"# 数组的创建\n",
|
||||
"\n",
|
||||
"导入 numpy。\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"import numpy as np\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"numpy 提供的最重要的数据结构是`ndarray`，它是 python 中`list`的扩展。\n",
|
||||
"\n",
|
||||
"## 1. 依据现有数据来创建 ndarray\n",
|
||||
"\n",
|
||||
"### **（a）通过array()函数进行创建。**\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def array(p_object, dtype=None, copy=True, order='K', subok=False, ndmin=0): \n",
|
||||
"``` \n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"# 创建一维数组\n",
|
||||
"a = np.array([0, 1, 2, 3, 4])\n",
|
||||
"b = np.array((0, 1, 2, 3, 4))\n",
|
||||
"print(a, type(a))\n",
|
||||
"# [0 1 2 3 4] <class 'numpy.ndarray'>\n",
|
||||
"print(b, type(b))\n",
|
||||
"# [0 1 2 3 4] <class 'numpy.ndarray'>\n",
|
||||
"\n",
|
||||
"# 创建二维数组\n",
|
||||
"c = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"print(c, type(c))\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]] <class 'numpy.ndarray'>\n",
|
||||
"\n",
|
||||
"# 创建三维数组\n",
|
||||
"d = np.array([[(1.5, 2, 3), (4, 5, 6)],\n",
|
||||
" [(3, 2, 1), (4, 5, 6)]])\n",
|
||||
"print(d, type(d))\n",
|
||||
"# [[[1.5 2. 3. ]\n",
|
||||
"# [4. 5. 6. ]]\n",
|
||||
"#\n",
|
||||
"# [[3. 2. 1. ]\n",
|
||||
"# [4. 5. 6. ]]] <class 'numpy.ndarray'>\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（b）通过asarray()函数进行创建**\n",
|
||||
"\n",
|
||||
"`array()`和`asarray()`都可以将结构数据转化为 ndarray，但是`array()`和`asarray()`主要区别就是当数据源是**ndarray** 时，`array()`仍然会 copy 出一个副本，占用新的内存，但不改变 dtype 时 `asarray()`不会。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def asarray(a, dtype=None, order=None):\n",
|
||||
" return array(a, dtype, copy=False, order=order)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】`array()`和`asarray()`都可以将结构数据转化为 ndarray\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]\n",
|
||||
"y = np.array(x)\n",
|
||||
"z = np.asarray(x)\n",
|
||||
"x[1][2] = 2\n",
|
||||
"print(x,type(x))\n",
|
||||
"# [[1, 1, 1], [1, 1, 2], [1, 1, 1]] <class 'list'>\n",
|
||||
"\n",
|
||||
"print(y,type(y))\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 1]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'>\n",
|
||||
"\n",
|
||||
"print(z,type(z))\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 1]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'>\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】`array()`和`asarray()`的区别。(`array()`和`asarray()`主要区别就是当数据源是**ndarray** 时，`array()`仍然会 copy 出一个副本，占用新的内存，但不改变 dtype 时 `asarray()`不会。)\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\n",
|
||||
"y = np.array(x)\n",
|
||||
"z = np.asarray(x)\n",
|
||||
"w = np.asarray(x, dtype=np.int)\n",
|
||||
"x[1][2] = 2\n",
|
||||
"print(x,type(x),x.dtype)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 2]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'> int32\n",
|
||||
"\n",
|
||||
"print(y,type(y),y.dtype)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 1]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'> int32\n",
|
||||
"\n",
|
||||
"print(z,type(z),z.dtype)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 2]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'> int32\n",
|
||||
"\n",
|
||||
"print(w,type(w),w.dtype)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 2]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'> int32\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】更改为较大的dtype时，其大小必须是array的最后一个axis的总大小（以字节为单位）的除数\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\n",
|
||||
"print(x, x.dtype)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 1]\n",
|
||||
"# [1 1 1]] int32\n",
|
||||
"x.dtype = np.float\n",
|
||||
"\n",
|
||||
"# ValueError: When changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（c）通过fromfunction()函数进行创建**\n",
|
||||
"\n",
|
||||
"给函数绘图的时候可能会用到`fromfunction()`，该函数可从函数中创建数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def fromfunction(function, shape, **kwargs):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】通过在每个坐标上执行一个函数来构造数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"def f(x, y):\n",
|
||||
" return 10 * x + y\n",
|
||||
"\n",
|
||||
"x = np.fromfunction(f, (5, 4), dtype=int)\n",
|
||||
"print(x)\n",
|
||||
"# [[ 0 1 2 3]\n",
|
||||
"# [10 11 12 13]\n",
|
||||
"# [20 21 22 23]\n",
|
||||
"# [30 31 32 33]\n",
|
||||
"# [40 41 42 43]]\n",
|
||||
"\n",
|
||||
"x = np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)\n",
|
||||
"print(x)\n",
|
||||
"# [[ True False False]\n",
|
||||
"# [False True False]\n",
|
||||
"# [False False True]]\n",
|
||||
"\n",
|
||||
"x = np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)\n",
|
||||
"print(x)\n",
|
||||
"# [[0 1 2]\n",
|
||||
"# [1 2 3]\n",
|
||||
"# [2 3 4]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 2. 依据 ones 和 zeros 填充方式\n",
|
||||
"\n",
|
||||
"在机器学习任务中经常做的一件事就是初始化参数，需要用常数值或者随机值来创建一个固定大小的矩阵。\n",
|
||||
"\n",
|
||||
"### **（a）零数组**\n",
|
||||
"\n",
|
||||
"- `zeros()`函数：返回给定形状和类型的零数组。\n",
|
||||
"- `zeros_like()`函数：返回与给定数组形状和类型相同的零数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def zeros(shape, dtype=None, order='C'):\n",
|
||||
"def zeros_like(a, dtype=None, order='K', subok=True, shape=None):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.zeros(5)\n",
|
||||
"print(x) # [0. 0. 0. 0. 0.]\n",
|
||||
"x = np.zeros([2, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[0. 0. 0.]\n",
|
||||
"# [0. 0. 0.]]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.zeros_like(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[0 0 0]\n",
|
||||
"# [0 0 0]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（b）1数组**\n",
|
||||
"\n",
|
||||
"- `ones()`函数：返回给定形状和类型的1数组。\n",
|
||||
"- `ones_like()`函数：返回与给定数组形状和类型相同的1数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def ones(shape, dtype=None, order='C'):\n",
|
||||
"def ones_like(a, dtype=None, order='K', subok=True, shape=None):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.ones(5)\n",
|
||||
"print(x) # [1. 1. 1. 1. 1.]\n",
|
||||
"x = np.ones([2, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[1. 1. 1.]\n",
|
||||
"# [1. 1. 1.]]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.ones_like(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 1]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（c）空数组**\n",
|
||||
"\n",
|
||||
"- `empty()`函数：返回一个空数组，数组元素为随机数。\n",
|
||||
"- `empty_like`函数：返回与给定数组具有相同形状和类型的新数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def empty(shape, dtype=None, order='C'): \n",
|
||||
"def empty_like(prototype, dtype=None, order='K', subok=True, shape=None):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.empty(5)\n",
|
||||
"print(x)\n",
|
||||
"# [1.95821574e-306 1.60219035e-306 1.37961506e-306 \n",
|
||||
"# 9.34609790e-307 1.24610383e-306]\n",
|
||||
"\n",
|
||||
"x = np.empty((3, 2))\n",
|
||||
"print(x)\n",
|
||||
"# [[1.60220393e-306 9.34587382e-307]\n",
|
||||
"# [8.45599367e-307 7.56598449e-307]\n",
|
||||
"# [1.33509389e-306 3.59412896e-317]]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.empty_like(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 7209029 6422625 6619244]\n",
|
||||
"# [ 100 707539280 504]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（d）单位数组**\n",
|
||||
"\n",
|
||||
"- `eye()`函数：返回一个对角线上为1，其它地方为零的单位数组。\n",
|
||||
"- `identity()`函数：返回一个方的单位数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def eye(N, M=None, k=0, dtype=float, order='C'):\n",
|
||||
"def identity(n, dtype=None):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.eye(4)\n",
|
||||
"print(x)\n",
|
||||
"# [[1. 0. 0. 0.]\n",
|
||||
"# [0. 1. 0. 0.]\n",
|
||||
"# [0. 0. 1. 0.]\n",
|
||||
"# [0. 0. 0. 1.]]\n",
|
||||
"\n",
|
||||
"x = np.eye(2, 3)\n",
|
||||
"print(x)\n",
|
||||
"# [[1. 0. 0.]\n",
|
||||
"# [0. 1. 0.]]\n",
|
||||
"\n",
|
||||
"x = np.identity(4)\n",
|
||||
"print(x)\n",
|
||||
"# [[1. 0. 0. 0.]\n",
|
||||
"# [0. 1. 0. 0.]\n",
|
||||
"# [0. 0. 1. 0.]\n",
|
||||
"# [0. 0. 0. 1.]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（e）对角数组**\n",
|
||||
"\n",
|
||||
"- `diag()`函数：提取对角线或构造对角数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def diag(v, k=0):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(9).reshape((3, 3))\n",
|
||||
"print(x)\n",
|
||||
"# [[0 1 2]\n",
|
||||
"# [3 4 5]\n",
|
||||
"# [6 7 8]]\n",
|
||||
"print(np.diag(x)) # [0 4 8]\n",
|
||||
"print(np.diag(x, k=1)) # [1 5]\n",
|
||||
"print(np.diag(x, k=-1)) # [3 7]\n",
|
||||
"\n",
|
||||
"v = [1, 3, 5, 7]\n",
|
||||
"x = np.diag(v)\n",
|
||||
"print(x)\n",
|
||||
"# [[1 0 0 0]\n",
|
||||
"# [0 3 0 0]\n",
|
||||
"# [0 0 5 0]\n",
|
||||
"# [0 0 0 7]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（f）常数数组**\n",
|
||||
"\n",
|
||||
"- `full()`函数：返回一个常数数组。\n",
|
||||
"- `full_like()`函数：返回与给定数组具有相同形状和类型的常数数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def full(shape, fill_value, dtype=None, order='C'):\n",
|
||||
"def full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.full((2,), 7)\n",
|
||||
"print(x)\n",
|
||||
"# [7 7]\n",
|
||||
"\n",
|
||||
"x = np.full(2, 7)\n",
|
||||
"print(x)\n",
|
||||
"# [7 7]\n",
|
||||
"\n",
|
||||
"x = np.full((2, 7), 7)\n",
|
||||
"print(x)\n",
|
||||
"# [[7 7 7 7 7 7 7]\n",
|
||||
"# [7 7 7 7 7 7 7]]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.full_like(x, 7)\n",
|
||||
"print(y)\n",
|
||||
"# [[7 7 7]\n",
|
||||
"# [7 7 7]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 3. 利用数值范围来创建ndarray\n",
|
||||
" - `arange()`函数：返回给定间隔内的均匀间隔的值。\n",
|
||||
" - `linspace()`函数：返回指定间隔内的等间隔数字。\n",
|
||||
" - `logspace()`函数：返回数以对数刻度均匀分布。\n",
|
||||
" - `numpy.random.rand()` 返回一个由[0,1)内的随机数组成的数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def arange([start,] stop[, step,], dtype=None): \n",
|
||||
"def linspace(start, stop, num=50, endpoint=True, retstep=False, \n",
|
||||
" dtype=None, axis=0):\n",
|
||||
"def logspace(start, stop, num=50, endpoint=True, base=10.0, \n",
|
||||
" dtype=None, axis=0):\n",
|
||||
"def rand(d0, d1, ..., dn): \n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(5)\n",
|
||||
"print(x) # [0 1 2 3 4]\n",
|
||||
"\n",
|
||||
"x = np.arange(3, 7, 2)\n",
|
||||
"print(x) # [3 5]\n",
|
||||
"\n",
|
||||
"x = np.linspace(start=0, stop=2, num=9)\n",
|
||||
"print(x) \n",
|
||||
"# [0. 0.25 0.5 0.75 1. 1.25 1.5 1.75 2. ]\n",
|
||||
"\n",
|
||||
"x = np.logspace(0, 1, 5)\n",
|
||||
"print(np.around(x, 2))\n",
|
||||
"# [ 1. 1.78 3.16 5.62 10. ] \n",
|
||||
" #np.around 返回四舍五入后的值，可指定精度。\n",
|
||||
" # around(a, decimals=0, out=None)\n",
|
||||
" # a 输入数组\n",
|
||||
" # decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"x = np.linspace(start=0, stop=1, num=5)\n",
|
||||
"x = [10 ** i for i in x]\n",
|
||||
"print(np.around(x, 2))\n",
|
||||
"# [ 1. 1.78 3.16 5.62 10. ]\n",
|
||||
"\n",
|
||||
"x = np.random.random(5)\n",
|
||||
"print(x)\n",
|
||||
"# [0.41768753 0.16315577 0.80167915 0.99690199 0.11812291]\n",
|
||||
"\n",
|
||||
"x = np.random.random([2, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[0.41151858 0.93785153 0.57031309]\n",
|
||||
"# [0.13482333 0.20583516 0.45429181]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 4. 结构数组的创建\n",
|
||||
"\n",
|
||||
"结构数组，首先需要定义结构，然后利用`np.array()`来创建数组，其参数`dtype`为定义的结构。\n",
|
||||
"\n",
|
||||
"### **（a）利用字典来定义结构**\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"personType = np.dtype({\n",
|
||||
" 'names': ['name', 'age', 'weight'],\n",
|
||||
" 'formats': ['U30', 'i8', 'f8']})\n",
|
||||
"\n",
|
||||
"a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],\n",
|
||||
" dtype=personType)\n",
|
||||
"print(a, type(a))\n",
|
||||
"# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]\n",
|
||||
"# <class 'numpy.ndarray'>\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（b）利用包含多个元组的列表来定义结构**\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"personType = np.dtype([('name', 'U30'), ('age', 'i8'), ('weight', 'f8')])\n",
|
||||
"a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],\n",
|
||||
" dtype=personType)\n",
|
||||
"print(a, type(a))\n",
|
||||
"# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]\n",
|
||||
"# <class 'numpy.ndarray'>\n",
|
||||
"\n",
|
||||
"# 结构数组的取值方式和一般数组差不多，可以通过下标取得元素：\n",
|
||||
"print(a[0])\n",
|
||||
"# ('Liming', 24, 63.9)\n",
|
||||
"\n",
|
||||
"print(a[-2:])\n",
|
||||
"# [('Mike', 15, 67. ) ('Jan', 34, 45.8)]\n",
|
||||
"\n",
|
||||
"# 我们可以使用字段名作为下标获取对应的值\n",
|
||||
"print(a['name'])\n",
|
||||
"# ['Liming' 'Mike' 'Jan']\n",
|
||||
"print(a['age'])\n",
|
||||
"# [24 15 34]\n",
|
||||
"print(a['weight'])\n",
|
||||
"# [63.9 67. 45.8]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"# 数组的属性\n",
|
||||
"\n",
|
||||
"在使用 numpy 时，你会想知道数组的某些信息。很幸运，在这个包里边包含了很多便捷的方法，可以给你想要的信息。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
" - `numpy.ndarray.ndim`用于返回数组的维数（轴的个数）也称为秩，一维数组的秩为 1，二维数组的秩为 2，以此类推。\n",
|
||||
" - `numpy.ndarray.shape`表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 `ndim` 属性(秩)。\n",
|
||||
" - `numpy.ndarray.size`数组中所有元素的总量，相当于数组的`shape`中所有元素的乘积，例如矩阵的元素总量为行与列的乘积。\n",
|
||||
" - `numpy.ndarray.dtype` `ndarray` 对象的元素类型。\n",
|
||||
" - `numpy.ndarray.itemsize`以字节的形式返回数组中每一个元素的大小。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"class ndarray(object):\n",
|
||||
" shape = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
|
||||
" dtype = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
|
||||
" size = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
|
||||
" ndim = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
|
||||
" itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.array([1, 2, 3, 4, 5])\n",
|
||||
"print(a.shape) # (5,)\n",
|
||||
"print(a.dtype) # int32\n",
|
||||
"print(a.size) # 5\n",
|
||||
"print(a.ndim) # 1\n",
|
||||
"print(a.itemsize) # 4\n",
|
||||
"\n",
|
||||
"b = np.array([[1, 2, 3], [4, 5, 6.0]])\n",
|
||||
"print(b.shape) # (2, 3)\n",
|
||||
"print(b.dtype) # float64\n",
|
||||
"print(b.size) # 6\n",
|
||||
"print(b.ndim) # 2\n",
|
||||
"print(b.itemsize) # 8\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"在`ndarray`中所有元素必须是同一类型，否则会自动向下转换，`int->float->str`。\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.array([1, 2, 3, 4, 5])\n",
|
||||
"print(a) # [1 2 3 4 5]\n",
|
||||
"b = np.array([1, 2, 3, 4, '5'])\n",
|
||||
"print(b) # ['1' '2' '3' '4' '5']\n",
|
||||
"c = np.array([1, 2, 3, 4, 5.0])\n",
|
||||
"print(c) # [1. 2. 3. 4. 5.]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.6.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {
|
||||
"height": "calc(100% - 180px)",
|
||||
"left": "10px",
|
||||
"top": "150px",
|
||||
"width": "307.2px"
|
||||
},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,731 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 4,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-29T16:29:25.164182Z",
|
||||
"start_time": "2020-08-29T16:29:25.155206Z"
|
||||
}
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[[[11 12 13 14 15]\n",
|
||||
" [16 17 18 19 20]]\n",
|
||||
"\n",
|
||||
" [[26 27 28 29 30]\n",
|
||||
" [31 32 33 34 35]]]\n",
|
||||
"[[[11 12 13 14 15]\n",
|
||||
" [11 12 13 14 15]]\n",
|
||||
"\n",
|
||||
" [[31 32 33 34 35]\n",
|
||||
" [31 32 33 34 35]]]\n",
|
||||
"[[11 15]\n",
|
||||
" [31 35]]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"import numpy as np\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"r = np.array([[0, 1], [3, 4]])\n",
|
||||
"print(x[r])\n",
|
||||
"# [[[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]]\n",
|
||||
"#\n",
|
||||
"# [[26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]]\n",
|
||||
"\n",
|
||||
"# 获取了 5X5 数组中的四个角的元素。\n",
|
||||
"# 行索引是 [0,0] 和 [4,4]，而列索引是 [0,4] 和 [0,4]。\n",
|
||||
"r = np.array([[0, 0], [4, 4]])\n",
|
||||
"c = np.array([[0, 4], [0, 4]])\n",
|
||||
"print(x[r])\n",
|
||||
"# [[[11 12 13 14 15]\n",
|
||||
"# [11 12 13 14 15]]\n",
|
||||
"\n",
|
||||
"# [[31 32 33 34 35]\n",
|
||||
"# [31 32 33 34 35]]]\n",
|
||||
"y = x[r, c]\n",
|
||||
"print(y)\n",
|
||||
"# [[11 15]\n",
|
||||
"# [31 35]]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-29T16:28:32.299732Z",
|
||||
"start_time": "2020-08-29T16:28:32.291752Z"
|
||||
}
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"array([[[11, 12, 13, 14, 15],\n",
|
||||
" [11, 12, 13, 14, 15]],\n",
|
||||
"\n",
|
||||
" [[31, 32, 33, 34, 35],\n",
|
||||
" [31, 32, 33, 34, 35]]])"
|
||||
]
|
||||
},
|
||||
"execution_count": 3,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"x[r][c]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 9,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-29T16:35:08.531558Z",
|
||||
"start_time": "2020-08-29T16:35:08.525575Z"
|
||||
}
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[[[11 12 13]\n",
|
||||
" [13 14 15]]\n",
|
||||
"\n",
|
||||
" [[16 17 18]\n",
|
||||
" [18 19 20]]\n",
|
||||
"\n",
|
||||
" [[21 22 23]\n",
|
||||
" [23 24 25]]\n",
|
||||
"\n",
|
||||
" [[26 27 28]\n",
|
||||
" [28 29 30]]\n",
|
||||
"\n",
|
||||
" [[31 32 33]\n",
|
||||
" [33 34 35]]]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"r = [0, 1, 2]\n",
|
||||
"c = [2, 3, 4]\n",
|
||||
"y = np.take(x, [r, c],axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [[11 12 13]\n",
|
||||
"# [13 14 15]]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 副本与视图\n",
|
||||
"在 Numpy 中，尤其是在做数组运算或数组操作时，返回结果不是数组的 **副本** 就是 **视图**。\n",
|
||||
"\n",
|
||||
"在 Numpy 中，所有赋值运算不会为数组和数组中的任何元素创建副本。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.ndarray.copy()` 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"y = x\n",
|
||||
"y[0] = -1\n",
|
||||
"print(x)\n",
|
||||
"# [-1 2 3 4 5 6 7 8]\n",
|
||||
"print(y)\n",
|
||||
"# [-1 2 3 4 5 6 7 8]\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"y = x.copy()\n",
|
||||
"y[0] = -1\n",
|
||||
"print(x)\n",
|
||||
"# [1 2 3 4 5 6 7 8]\n",
|
||||
"print(y)\n",
|
||||
"# [-1 2 3 4 5 6 7 8]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】数组切片操作返回的对象只是原数组的视图。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = x\n",
|
||||
"y[::2, :3:2] = -1\n",
|
||||
"print(x)\n",
|
||||
"# [[-1 12 -1 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [-1 22 -1 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [-1 32 -1 34 35]]\n",
|
||||
"print(y)\n",
|
||||
"# [[-1 12 -1 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [-1 22 -1 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [-1 32 -1 34 35]]\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = x.copy()\n",
|
||||
"y[::2, :3:2] = -1\n",
|
||||
"print(x)\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"print(y)\n",
|
||||
"# [[-1 12 -1 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [-1 22 -1 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [-1 32 -1 34 35]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"# 索引与切片\n",
|
||||
"\n",
|
||||
"数组索引机制指的是用方括号（[]）加序号的形式引用单个数组元素，它的用处很多，比如抽取元素，选取数组的几个元素，甚至为其赋一个新值。\n",
|
||||
"\n",
|
||||
"## 整数索引\n",
|
||||
"\n",
|
||||
"【例】要获取数组的单个元素，指定元素的索引即可。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"print(x[2]) # 3\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"print(x[2]) # [21 22 23 24 25]\n",
|
||||
"print(x[2][1]) # 22\n",
|
||||
"print(x[2, 1]) # 22\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"## 切片索引\n",
|
||||
"\n",
|
||||
"切片操作是指抽取数组的一部分元素生成新数组。对 python **列表**进行切片操作得到的数组是原数组的**副本**，而对 **Numpy** 数据进行切片操作得到的数组则是指向相同缓冲区的**视图**。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"如果想抽取（或查看）数组的一部分，必须使用切片语法，也就是，把几个用冒号（ `start:stop:step` ）隔开的数字置于方括号内。\n",
|
||||
"\n",
|
||||
"为了更好地理解切片语法，还应该了解不明确指明起始和结束位置的情况。如省去第一个数字，numpy 会认为第一个数字是0；如省去第二个数字，numpy 则会认为第二个数字是数组的最大索引值；如省去最后一个数字，它将会被理解为1，也就是抽取所有元素而不再考虑间隔。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】对一维数组的切片\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"print(x[0:2]) # [1 2]\n",
|
||||
"print(x[1:5:2]) # [2 4]\n",
|
||||
"print(x[2:]) # [3 4 5 6 7 8]\n",
|
||||
"print(x[:2]) # [1 2]\n",
|
||||
"print(x[-2:]) # [7 8]\n",
|
||||
"print(x[:-2]) # [1 2 3 4 5 6]\n",
|
||||
"print(x[:]) # [1 2 3 4 5 6 7 8]\n",
|
||||
"print(x[::-1]) # [8 7 6 5 4 3 2 1]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】对二维数组切片\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"print(x[0:2])\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]]\n",
|
||||
"\n",
|
||||
"print(x[1:5:2])\n",
|
||||
"# [[16 17 18 19 20]\n",
|
||||
"# [26 27 28 29 30]]\n",
|
||||
"\n",
|
||||
"print(x[2:])\n",
|
||||
"# [[21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"\n",
|
||||
"print(x[:2])\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]]\n",
|
||||
"\n",
|
||||
"print(x[-2:])\n",
|
||||
"# [[26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"\n",
|
||||
"print(x[:-2])\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]]\n",
|
||||
"\n",
|
||||
"print(x[:])\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"\n",
|
||||
"print(x[2, :]) # [21 22 23 24 25]\n",
|
||||
"print(x[:, 2]) # [13 18 23 28 33]\n",
|
||||
"print(x[0, 1:4]) # [12 13 14]\n",
|
||||
"print(x[1:4, 0]) # [16 21 26]\n",
|
||||
"print(x[1:3, 2:4])\n",
|
||||
"# [[18 19]\n",
|
||||
"# [23 24]]\n",
|
||||
"\n",
|
||||
"print(x[:, :])\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"\n",
|
||||
"print(x[::2, ::2])\n",
|
||||
"# [[11 13 15]\n",
|
||||
"# [21 23 25]\n",
|
||||
"# [31 33 35]]\n",
|
||||
"\n",
|
||||
"print(x[::-1, :])\n",
|
||||
"# [[31 32 33 34 35]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [11 12 13 14 15]]\n",
|
||||
"\n",
|
||||
"print(x[:, ::-1])\n",
|
||||
"# [[15 14 13 12 11]\n",
|
||||
"# [20 19 18 17 16]\n",
|
||||
"# [25 24 23 22 21]\n",
|
||||
"# [30 29 28 27 26]\n",
|
||||
"# [35 34 33 32 31]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"通过对每个以逗号分隔的维度执行单独的切片，你可以对多维数组进行切片。因此，对于二维数组，我们的第一片定义了行的切片，第二片定义了列的切片。\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"print(x)\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"\n",
|
||||
"x[0::2, 1::3] = 0\n",
|
||||
"print(x)\n",
|
||||
"# [[11 0 13 14 0]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 0 23 24 0]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 0 33 34 0]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"## dots 索引\n",
|
||||
"\n",
|
||||
"NumPy 允许使用`...`表示足够多的冒号来构建完整的索引列表。\n",
|
||||
"\n",
|
||||
"比如，如果 `x` 是 5 维数组：\n",
|
||||
"\n",
|
||||
"- `x[1,2,...]` 等于 `x[1,2,:,:,:]`\n",
|
||||
"- `x[...,3]` 等于 `x[:,:,:,:,3]` \n",
|
||||
"- `x[4,...,5,:]` 等于 `x[4,:,:,5,:]`\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.random.randint(1, 100, [2, 2, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[[ 5 64 75]\n",
|
||||
"# [57 27 31]]\n",
|
||||
"# \n",
|
||||
"# [[68 85 3]\n",
|
||||
"# [93 26 25]]]\n",
|
||||
"\n",
|
||||
"print(x[1, ...])\n",
|
||||
"# [[68 85 3]\n",
|
||||
"# [93 26 25]]\n",
|
||||
"\n",
|
||||
"print(x[..., 2])\n",
|
||||
"# [[75 31]\n",
|
||||
"# [ 3 25]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 整数数组索引\n",
|
||||
"\n",
|
||||
"【例】方括号内传入多个索引值，可以同时选择多个元素。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"r = [0, 1, 2]\n",
|
||||
"print(x[r])\n",
|
||||
"# [1 2 3]\n",
|
||||
"\n",
|
||||
"r = [0, 1, -1]\n",
|
||||
"print(x[r])\n",
|
||||
"# [1 2 8]\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"r = [0, 1, 2]\n",
|
||||
"print(x[r])\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]]\n",
|
||||
"\n",
|
||||
"r = [0, 1, -1]\n",
|
||||
"print(x[r])\n",
|
||||
"\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"\n",
|
||||
"r = [0, 1, 2]\n",
|
||||
"c = [2, 3, 4]\n",
|
||||
"y = x[r, c]\n",
|
||||
"print(y)\n",
|
||||
"# [13 19 25]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"r = np.array([[0, 1], [3, 4]])\n",
|
||||
"print(x[r])\n",
|
||||
"# [[1 2]\n",
|
||||
"# [4 5]]\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"r = np.array([[0, 1], [3, 4]])\n",
|
||||
"print(x[r])\n",
|
||||
"# [[[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]]\n",
|
||||
"#\n",
|
||||
"# [[26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]]\n",
|
||||
"\n",
|
||||
"# 获取了 5X5 数组中的四个角的元素。\n",
|
||||
"# 行索引是 [0,0] 和 [4,4]，而列索引是 [0,4] 和 [0,4]。\n",
|
||||
"r = np.array([[0, 0], [4, 4]])\n",
|
||||
"c = np.array([[0, 4], [0, 4]])\n",
|
||||
"y = x[r, c]\n",
|
||||
"print(y)\n",
|
||||
"# [[11 15]\n",
|
||||
"# [31 35]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】可以借助切片`:`与整数数组组合。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"y = x[0:3, [1, 2, 2]]\n",
|
||||
"print(y)\n",
|
||||
"# [[12 13 13]\n",
|
||||
"# [17 18 18]\n",
|
||||
"# [22 23 23]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy. take(a, indices, axis=None, out=None, mode='raise')` Take elements from an array along an axis.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"r = [0, 1, 2]\n",
|
||||
"print(np.take(x, r))\n",
|
||||
"# [1 2 3]\n",
|
||||
"\n",
|
||||
"r = [0, 1, -1]\n",
|
||||
"print(np.take(x, r))\n",
|
||||
"# [1 2 8]\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"r = [0, 1, 2]\n",
|
||||
"print(np.take(x, r, axis=0))\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]]\n",
|
||||
"\n",
|
||||
"r = [0, 1, -1]\n",
|
||||
"print(np.take(x, r, axis=0))\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"\n",
|
||||
"r = [0, 1, 2]\n",
|
||||
"c = [2, 3, 4]\n",
|
||||
"y = np.take(x, [r, c])\n",
|
||||
"print(y)\n",
|
||||
"# [[11 12 13]\n",
|
||||
"# [13 14 15]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 布尔索引\n",
|
||||
"\n",
|
||||
"我们可以通过一个布尔数组来索引目标数组。\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"y = x > 5\n",
|
||||
"print(y)\n",
|
||||
"# [False False False False False True True True]\n",
|
||||
"print(x[x > 5])\n",
|
||||
"# [6 7 8]\n",
|
||||
"\n",
|
||||
"x = np.array([np.nan, 1, 2, np.nan, 3, 4, 5])\n",
|
||||
"y = np.logical_not(np.isnan(x))\n",
|
||||
"print(x[y])\n",
|
||||
"# [1. 2. 3. 4. 5.]\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = x > 25\n",
|
||||
"print(y)\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]]\n",
|
||||
"print(x[x > 25])\n",
|
||||
"# [26 27 28 29 30 31 32 33 34 35]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"import matplotlib.pyplot as plt\n",
|
||||
"\n",
|
||||
"x = np.linspace(0, 2 * np.pi, 50)\n",
|
||||
"y = np.sin(x)\n",
|
||||
"print(len(x)) # 50\n",
|
||||
"plt.plot(x, y)\n",
|
||||
"\n",
|
||||
"mask = y >= 0\n",
|
||||
"print(len(x[mask])) # 25\n",
|
||||
"print(mask)\n",
|
||||
"'''\n",
|
||||
"[ True True True True True True True True True True True True\n",
|
||||
" True True True True True True True True True True True True\n",
|
||||
" True False False False False False False False False False False False\n",
|
||||
" False False False False False False False False False False False False\n",
|
||||
" False False]\n",
|
||||
"'''\n",
|
||||
"plt.plot(x[mask], y[mask], 'bo')\n",
|
||||
"\n",
|
||||
"mask = np.logical_and(y >= 0, x <= np.pi / 2)\n",
|
||||
"print(mask)\n",
|
||||
"'''\n",
|
||||
"[ True True True True True True True True True True True True\n",
|
||||
" True False False False False False False False False False False False\n",
|
||||
" False False False False False False False False False False False False\n",
|
||||
" False False False False False False False False False False False False\n",
|
||||
" False False]\n",
|
||||
"'''\n",
|
||||
"\n",
|
||||
"plt.plot(x[mask], y[mask], 'go')\n",
|
||||
"plt.show()\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"我们利用这些条件来选择图上的不同点。蓝色点（在图中还包括绿点，但绿点掩盖了蓝色点），显示值 大于0 的所有点。绿色点表示值 大于0 且 小于0.5π 的所有点。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"# 数组迭代\n",
|
||||
"\n",
|
||||
"除了for循环，Numpy 还提供另外一种更为优雅的遍历方法。\n",
|
||||
"\n",
|
||||
"- `apply_along_axis(func1d, axis, arr)` Apply a function to 1-D slices along the given axis.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"y = np.apply_along_axis(np.sum, 0, x)\n",
|
||||
"print(y) # [105 110 115 120 125]\n",
|
||||
"y = np.apply_along_axis(np.sum, 1, x)\n",
|
||||
"print(y) # [ 65 90 115 140 165]\n",
|
||||
"\n",
|
||||
"y = np.apply_along_axis(np.mean, 0, x)\n",
|
||||
"print(y) # [21. 22. 23. 24. 25.]\n",
|
||||
"y = np.apply_along_axis(np.mean, 1, x)\n",
|
||||
"print(y) # [13. 18. 23. 28. 33.]\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"def my_func(x):\n",
|
||||
" return (x[0] + x[-1]) * 0.5\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"y = np.apply_along_axis(my_func, 0, x)\n",
|
||||
"print(y) # [21. 22. 23. 24. 25.]\n",
|
||||
"y = np.apply_along_axis(my_func, 1, x)\n",
|
||||
"print(y) # [13. 18. 23. 28. 33.]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.6.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {
|
||||
"height": "calc(100% - 180px)",
|
||||
"left": "10px",
|
||||
"top": "150px",
|
||||
"width": "307.2px"
|
||||
},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,892 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-30T13:35:08.895856Z",
|
||||
"start_time": "2020-08-30T13:35:08.889872Z"
|
||||
}
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[[ 1. 2. 3.]\n",
|
||||
" [11. 12. 13.]\n",
|
||||
" [21. 22. 23.]\n",
|
||||
" [31. 32. 33.]]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"import numpy as np\n",
|
||||
"x = np.array([0.0, 10.0, 20.0, 30.0])\n",
|
||||
"y = np.array([1.0, 2.0, 3.0])\n",
|
||||
"z = x[:, np.newaxis] + y\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1. 2. 3.]\n",
|
||||
"# [11. 12. 13.]\n",
|
||||
"# [21. 22. 23.]\n",
|
||||
"# [31. 32. 33.]]"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-30T13:39:26.777758Z",
|
||||
"start_time": "2020-08-30T13:39:26.771774Z"
|
||||
}
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"(4,)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"(4, 1)"
|
||||
]
|
||||
},
|
||||
"execution_count": 5,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"x = np.array([0.0, 10.0, 20.0, 30.0])\n",
|
||||
"print(x.shape)\n",
|
||||
"x[:, np.newaxis].shape"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 向量化和广播\n",
|
||||
"\n",
|
||||
"向量化和广播这两个概念是 numpy 内部实现的基础。有了向量化，编写代码时无需使用显式循环。这些循环实际上不能省略，只不过是在内部实现，被代码中的其他结构代替。向量化的应用使得代码更简洁，可读性更强，也可以说使用了向量化方法的代码看上去更“Pythonic”。\n",
|
||||
"\n",
|
||||
"广播（Broadcasting）机制描述了 numpy 如何在算术运算期间处理具有不同形状的数组，让较小的数组在较大的数组上“广播”，以便它们具有兼容的形状。并不是所有的维度都要彼此兼容才符合广播机制的要求，但它们必须满足一定的条件。\n",
|
||||
"\n",
|
||||
"若两个数组的各维度兼容，也就是两个数组的每一维等长，或其中一个数组为 一维，那么广播机制就适用。如果这两个条件不满足，numpy就会抛出异常，说两个数组不兼容。\n",
|
||||
"\n",
|
||||
"总结来说，广播的规则有三个：\n",
|
||||
"- 如果两个数组的维度数dim不相同，那么小维度数组的形状将会在左边补1。\n",
|
||||
"- 如果shape维度不匹配，但是有维度是1，那么可以扩展维度是1的维度匹配另一个数组；\n",
|
||||
"- 如果shape维度不匹配，但是没有任何一个维度是1，则匹配引发错误；\n",
|
||||
"\n",
|
||||
"【例】二维数组加一维数组\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(4)\n",
|
||||
"y = np.ones((3, 4))\n",
|
||||
"print(x.shape) # (4,)\n",
|
||||
"print(y.shape) # (3, 4)\n",
|
||||
"\n",
|
||||
"print((x + y).shape) # (3, 4)\n",
|
||||
"print(x + y)\n",
|
||||
"# [[1. 2. 3. 4.]\n",
|
||||
"# [1. 2. 3. 4.]\n",
|
||||
"# [1. 2. 3. 4.]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】两个数组均需要广播\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(4).reshape(4, 1)\n",
|
||||
"y = np.ones(5)\n",
|
||||
"\n",
|
||||
"print(x.shape) # (4, 1)\n",
|
||||
"print(y.shape) # (5,)\n",
|
||||
"\n",
|
||||
"print((x + y).shape) # (4, 5)\n",
|
||||
"print(x + y)\n",
|
||||
"# [[1. 1. 1. 1. 1.]\n",
|
||||
"# [2. 2. 2. 2. 2.]\n",
|
||||
"# [3. 3. 3. 3. 3.]\n",
|
||||
"# [4. 4. 4. 4. 4.]]\n",
|
||||
"\n",
|
||||
"x = np.array([0.0, 10.0, 20.0, 30.0])\n",
|
||||
"y = np.array([1.0, 2.0, 3.0])\n",
|
||||
"z = x[:, np.newaxis] + y\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1. 2. 3.]\n",
|
||||
"# [11. 12. 13.]\n",
|
||||
"# [21. 22. 23.]\n",
|
||||
"# [31. 32. 33.]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】不匹配报错的例子\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(4)\n",
|
||||
"y = np.ones(5)\n",
|
||||
"\n",
|
||||
"print(x.shape) # (4,)\n",
|
||||
"print(y.shape) # (5,)\n",
|
||||
"\n",
|
||||
"print(x + y)\n",
|
||||
"# ValueError: operands could not be broadcast together with shapes (4,) (5,) \n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"# 数学函数\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 算数运算\n",
|
||||
"\n",
|
||||
"- `numpy.add(x1, x2, *args, **kwargs)` Add arguments element-wise.\n",
|
||||
"- `numpy.subtract(x1, x2, *args, **kwargs)` Subtract arguments element-wise.\n",
|
||||
"- `numpy.multiply(x1, x2, *args, **kwargs)` Multiply arguments element-wise.\n",
|
||||
"- `numpy.divide(x1, x2, *args, **kwargs)` Returns a true division of the inputs, element-wise.\n",
|
||||
"- `numpy.floor_divide(x1, x2, *args, **kwargs)` Return the largest integer smaller or equal to the division of the inputs.\n",
|
||||
"- `numpy.power(x1, x2, *args, **kwargs)` First array elements raised to powers from second array, element-wise.\n",
|
||||
"\n",
|
||||
"在 numpy 中对以上函数进行了运算符的重载，且运算符为 **元素级**。也就是说，它们只用于位置相同的元素之间，所得到的运算结果组成一个新的数组。\n",
|
||||
"\n",
|
||||
"【例】注意 numpy 的广播规则。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"y = x + 1\n",
|
||||
"print(y)\n",
|
||||
"print(np.add(x, 1))\n",
|
||||
"# [2 3 4 5 6 7 8 9]\n",
|
||||
"\n",
|
||||
"y = x - 1\n",
|
||||
"print(y)\n",
|
||||
"print(np.subtract(x, 1))\n",
|
||||
"# [0 1 2 3 4 5 6 7]\n",
|
||||
"\n",
|
||||
"y = x * 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.multiply(x, 2))\n",
|
||||
"# [ 2 4 6 8 10 12 14 16]\n",
|
||||
"\n",
|
||||
"y = x / 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.divide(x, 2))\n",
|
||||
"# [0.5 1. 1.5 2. 2.5 3. 3.5 4. ]\n",
|
||||
"\n",
|
||||
"y = x // 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.floor_divide(x, 2))\n",
|
||||
"# [0 1 1 2 2 3 3 4]\n",
|
||||
"\n",
|
||||
"y = x ** 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.power(x, 2))\n",
|
||||
"# [ 1 4 9 16 25 36 49 64]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】注意 numpy 的广播规则。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = x + 1\n",
|
||||
"print(y)\n",
|
||||
"print(np.add(x, 1))\n",
|
||||
"# [[12 13 14 15 16]\n",
|
||||
"# [17 18 19 20 21]\n",
|
||||
"# [22 23 24 25 26]\n",
|
||||
"# [27 28 29 30 31]\n",
|
||||
"# [32 33 34 35 36]]\n",
|
||||
"\n",
|
||||
"y = x - 1\n",
|
||||
"print(y)\n",
|
||||
"print(np.subtract(x, 1))\n",
|
||||
"# [[10 11 12 13 14]\n",
|
||||
"# [15 16 17 18 19]\n",
|
||||
"# [20 21 22 23 24]\n",
|
||||
"# [25 26 27 28 29]\n",
|
||||
"# [30 31 32 33 34]]\n",
|
||||
"\n",
|
||||
"y = x * 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.multiply(x, 2))\n",
|
||||
"# [[22 24 26 28 30]\n",
|
||||
"# [32 34 36 38 40]\n",
|
||||
"# [42 44 46 48 50]\n",
|
||||
"# [52 54 56 58 60]\n",
|
||||
"# [62 64 66 68 70]]\n",
|
||||
"\n",
|
||||
"y = x / 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.divide(x, 2))\n",
|
||||
"# [[ 5.5 6. 6.5 7. 7.5]\n",
|
||||
"# [ 8. 8.5 9. 9.5 10. ]\n",
|
||||
"# [10.5 11. 11.5 12. 12.5]\n",
|
||||
"# [13. 13.5 14. 14.5 15. ]\n",
|
||||
"# [15.5 16. 16.5 17. 17.5]]\n",
|
||||
"\n",
|
||||
"y = x // 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.floor_divide(x, 2))\n",
|
||||
"# [[ 5 6 6 7 7]\n",
|
||||
"# [ 8 8 9 9 10]\n",
|
||||
"# [10 11 11 12 12]\n",
|
||||
"# [13 13 14 14 15]\n",
|
||||
"# [15 16 16 17 17]]\n",
|
||||
"\n",
|
||||
"y = x ** 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.power(x, 2))\n",
|
||||
"# [[ 121 144 169 196 225]\n",
|
||||
"# [ 256 289 324 361 400]\n",
|
||||
"# [ 441 484 529 576 625]\n",
|
||||
"# [ 676 729 784 841 900]\n",
|
||||
"# [ 961 1024 1089 1156 1225]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】注意 numpy 的广播规则。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"y = np.arange(1, 6)\n",
|
||||
"print(y)\n",
|
||||
"# [1 2 3 4 5]\n",
|
||||
"\n",
|
||||
"z = x + y\n",
|
||||
"print(z)\n",
|
||||
"print(np.add(x, y))\n",
|
||||
"# [[12 14 16 18 20]\n",
|
||||
"# [17 19 21 23 25]\n",
|
||||
"# [22 24 26 28 30]\n",
|
||||
"# [27 29 31 33 35]\n",
|
||||
"# [32 34 36 38 40]]\n",
|
||||
"\n",
|
||||
"z = x - y\n",
|
||||
"print(z)\n",
|
||||
"print(np.subtract(x, y))\n",
|
||||
"# [[10 10 10 10 10]\n",
|
||||
"# [15 15 15 15 15]\n",
|
||||
"# [20 20 20 20 20]\n",
|
||||
"# [25 25 25 25 25]\n",
|
||||
"# [30 30 30 30 30]]\n",
|
||||
"\n",
|
||||
"z = x * y\n",
|
||||
"print(z)\n",
|
||||
"print(np.multiply(x, y))\n",
|
||||
"# [[ 11 24 39 56 75]\n",
|
||||
"# [ 16 34 54 76 100]\n",
|
||||
"# [ 21 44 69 96 125]\n",
|
||||
"# [ 26 54 84 116 150]\n",
|
||||
"# [ 31 64 99 136 175]]\n",
|
||||
"\n",
|
||||
"z = x / y\n",
|
||||
"print(z)\n",
|
||||
"print(np.divide(x, y))\n",
|
||||
"# [[11. 6. 4.33333333 3.5 3. ]\n",
|
||||
"# [16. 8.5 6. 4.75 4. ]\n",
|
||||
"# [21. 11. 7.66666667 6. 5. ]\n",
|
||||
"# [26. 13.5 9.33333333 7.25 6. ]\n",
|
||||
"# [31. 16. 11. 8.5 7. ]]\n",
|
||||
"\n",
|
||||
"z = x // y\n",
|
||||
"print(z)\n",
|
||||
"print(np.floor_divide(x, y))\n",
|
||||
"# [[11 6 4 3 3]\n",
|
||||
"# [16 8 6 4 4]\n",
|
||||
"# [21 11 7 6 5]\n",
|
||||
"# [26 13 9 7 6]\n",
|
||||
"# [31 16 11 8 7]]\n",
|
||||
"\n",
|
||||
"z = x ** np.full([1, 5], 2)\n",
|
||||
"print(z)\n",
|
||||
"print(np.power(x, np.full([5, 5], 2)))\n",
|
||||
"# [[ 121 144 169 196 225]\n",
|
||||
"# [ 256 289 324 361 400]\n",
|
||||
"# [ 441 484 529 576 625]\n",
|
||||
"# [ 676 729 784 841 900]\n",
|
||||
"# [ 961 1024 1089 1156 1225]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"y = np.arange(1, 26).reshape([5, 5])\n",
|
||||
"print(y)\n",
|
||||
"# [[ 1 2 3 4 5]\n",
|
||||
"# [ 6 7 8 9 10]\n",
|
||||
"# [11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]]\n",
|
||||
"\n",
|
||||
"z = x + y\n",
|
||||
"print(z)\n",
|
||||
"print(np.add(x, y))\n",
|
||||
"# [[12 14 16 18 20]\n",
|
||||
"# [22 24 26 28 30]\n",
|
||||
"# [32 34 36 38 40]\n",
|
||||
"# [42 44 46 48 50]\n",
|
||||
"# [52 54 56 58 60]]\n",
|
||||
"\n",
|
||||
"z = x - y\n",
|
||||
"print(z)\n",
|
||||
"print(np.subtract(x, y))\n",
|
||||
"# [[10 10 10 10 10]\n",
|
||||
"# [10 10 10 10 10]\n",
|
||||
"# [10 10 10 10 10]\n",
|
||||
"# [10 10 10 10 10]\n",
|
||||
"# [10 10 10 10 10]]\n",
|
||||
"\n",
|
||||
"z = x * y\n",
|
||||
"print(z)\n",
|
||||
"print(np.multiply(x, y))\n",
|
||||
"# [[ 11 24 39 56 75]\n",
|
||||
"# [ 96 119 144 171 200]\n",
|
||||
"# [231 264 299 336 375]\n",
|
||||
"# [416 459 504 551 600]\n",
|
||||
"# [651 704 759 816 875]]\n",
|
||||
"\n",
|
||||
"z = x / y\n",
|
||||
"print(z)\n",
|
||||
"print(np.divide(x, y))\n",
|
||||
"# [[11. 6. 4.33333333 3.5 3. ]\n",
|
||||
"# [ 2.66666667 2.42857143 2.25 2.11111111 2. ]\n",
|
||||
"# [ 1.90909091 1.83333333 1.76923077 1.71428571 1.66666667]\n",
|
||||
"# [ 1.625 1.58823529 1.55555556 1.52631579 1.5 ]\n",
|
||||
"# [ 1.47619048 1.45454545 1.43478261 1.41666667 1.4 ]]\n",
|
||||
"\n",
|
||||
"z = x // y\n",
|
||||
"print(z)\n",
|
||||
"print(np.floor_divide(x, y))\n",
|
||||
"# [[11 6 4 3 3]\n",
|
||||
"# [ 2 2 2 2 2]\n",
|
||||
"# [ 1 1 1 1 1]\n",
|
||||
"# [ 1 1 1 1 1]\n",
|
||||
"# [ 1 1 1 1 1]]\n",
|
||||
"\n",
|
||||
"z = x ** np.full([5, 5], 2)\n",
|
||||
"print(z)\n",
|
||||
"print(np.power(x, np.full([5, 5], 2)))\n",
|
||||
"# [[ 121 144 169 196 225]\n",
|
||||
"# [ 256 289 324 361 400]\n",
|
||||
"# [ 441 484 529 576 625]\n",
|
||||
"# [ 676 729 784 841 900]\n",
|
||||
"# [ 961 1024 1089 1156 1225]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.sqrt(x, *args, **kwargs)` Return the non-negative square-root of an array, element-wise.\n",
|
||||
"- `numpy.square(x, *args, **kwargs)` Return the element-wise square of the input.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(1, 5)\n",
|
||||
"print(x) # [1 2 3 4]\n",
|
||||
"\n",
|
||||
"y = np.sqrt(x)\n",
|
||||
"print(y)\n",
|
||||
"# [1. 1.41421356 1.73205081 2. ]\n",
|
||||
"print(np.power(x, 0.5))\n",
|
||||
"# [1. 1.41421356 1.73205081 2. ]\n",
|
||||
"\n",
|
||||
"y = np.square(x)\n",
|
||||
"print(y)\n",
|
||||
"# [ 1 4 9 16]\n",
|
||||
"print(np.power(x, 2))\n",
|
||||
"# [ 1 4 9 16]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 三角函数\n",
|
||||
"\n",
|
||||
"- `numpy.sin(x, *args, **kwargs)` Trigonometric sine, element-wise.\n",
|
||||
"- `numpy.cos(x, *args, **kwargs)` Cosine element-wise.\n",
|
||||
"- `numpy.tan(x, *args, **kwargs)` Compute tangent element-wise.\n",
|
||||
"- `numpy.arcsin(x, *args, **kwargs)` Inverse sine, element-wise.\n",
|
||||
"- `numpy.arccos(x, *args, **kwargs)` Trigonometric inverse cosine, element-wise.\n",
|
||||
"- `numpy.arctan(x, *args, **kwargs)` Trigonometric inverse tangent, element-wise.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"**通用函数**（universal function）通常叫作ufunc，它对数组中的各个元素逐一进行操作。这表明，通用函数分别处理输入数组的每个元素，生成的结果组成一个新的输出数组。输出数组的大小跟输入数组相同。\n",
|
||||
"\n",
|
||||
"三角函数等很多数学运算符合通用函数的定义，例如，计算平方根的`sqrt()`函数、用来取对数的`log()`函数和求正弦值的`sin()`函数。\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.linspace(start=0, stop=np.pi / 2, num=10)\n",
|
||||
"print(x)\n",
|
||||
"# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463\n",
|
||||
"# 1.04719755 1.22173048 1.3962634 1.57079633]\n",
|
||||
"\n",
|
||||
"y = np.sin(x)\n",
|
||||
"print(y)\n",
|
||||
"# [0. 0.17364818 0.34202014 0.5 0.64278761 0.76604444\n",
|
||||
"# 0.8660254 0.93969262 0.98480775 1. ]\n",
|
||||
"\n",
|
||||
"z = np.arcsin(y)\n",
|
||||
"print(z)\n",
|
||||
"# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463\n",
|
||||
"# 1.04719755 1.22173048 1.3962634 1.57079633]\n",
|
||||
"\n",
|
||||
"y = np.cos(x)\n",
|
||||
"print(y)\n",
|
||||
"# [1.00000000e+00 9.84807753e-01 9.39692621e-01 8.66025404e-01\n",
|
||||
"# 7.66044443e-01 6.42787610e-01 5.00000000e-01 3.42020143e-01\n",
|
||||
"# 1.73648178e-01 6.12323400e-17]\n",
|
||||
"\n",
|
||||
"z = np.arccos(y)\n",
|
||||
"print(z)\n",
|
||||
"# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463\n",
|
||||
"# 1.04719755 1.22173048 1.3962634 1.57079633]\n",
|
||||
"\n",
|
||||
"y = np.tan(x)\n",
|
||||
"print(y)\n",
|
||||
"# [0.00000000e+00 1.76326981e-01 3.63970234e-01 5.77350269e-01\n",
|
||||
"# 8.39099631e-01 1.19175359e+00 1.73205081e+00 2.74747742e+00\n",
|
||||
"# 5.67128182e+00 1.63312394e+16]\n",
|
||||
"\n",
|
||||
"z = np.arctan(y)\n",
|
||||
"print(z)\n",
|
||||
"# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463\n",
|
||||
"# 1.04719755 1.22173048 1.3962634 1.57079633]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 指数和对数\n",
|
||||
"\n",
|
||||
"- `numpy.exp(x, *args, **kwargs)` Calculate the exponential of all elements in the input array.\n",
|
||||
"- `numpy.log(x, *args, **kwargs)` Natural logarithm, element-wise.\n",
|
||||
"- `numpy.exp2(x, *args, **kwargs)` Calculate `2**p` for all `p` in the input array.\n",
|
||||
"- `numpy.log2(x, *args, **kwargs)` Base-2 logarithm of `x`.\n",
|
||||
"- `numpy.log10(x, *args, **kwargs)` Return the base 10 logarithm of the input array, element-wise.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】The natural logarithm `log` is the inverse of the exponential function, so that `log(exp(x)) = x`. The natural logarithm is logarithm in base `e`.\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(1, 5)\n",
|
||||
"print(x)\n",
|
||||
"# [1 2 3 4]\n",
|
||||
"y = np.exp(x)\n",
|
||||
"print(y)\n",
|
||||
"# [ 2.71828183 7.3890561 20.08553692 54.59815003]\n",
|
||||
"z = np.log(y)\n",
|
||||
"print(z)\n",
|
||||
"# [1. 2. 3. 4.]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 加法函数、乘法函数\n",
|
||||
"\n",
|
||||
"- `numpy.sum(a[, axis=None, dtype=None, out=None, …])` Sum of array elements over a given axis.\n",
|
||||
"\n",
|
||||
"通过不同的 `axis`，numpy 会沿着不同的方向进行操作：如果不设置，那么对所有的元素操作；如果`axis=0`，则沿着纵轴进行操作；`axis=1`，则沿着横轴进行操作。但这只是简单的二位数组，如果是多维的呢？可以总结为一句话：设`axis=i`，则 numpy 沿着第`i`个下标变化的方向进行操作。\n",
|
||||
"\n",
|
||||
"- `numpy.cumsum(a, axis=None, dtype=None, out=None)` Return the cumulative sum of the elements along a given axis.\n",
|
||||
"\n",
|
||||
"**聚合函数** 是指对一组值（比如一个数组）进行操作，返回一个单一值作为结果的函数。因而，求数组所有元素之和的函数就是聚合函数。`ndarray`类实现了多个这样的函数。\n",
|
||||
"\n",
|
||||
"【例】返回给定轴上的数组元素的总和。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.sum(x)\n",
|
||||
"print(y) # 575\n",
|
||||
"\n",
|
||||
"y = np.sum(x, axis=0)\n",
|
||||
"print(y) # [105 110 115 120 125]\n",
|
||||
"\n",
|
||||
"y = np.sum(x, axis=1)\n",
|
||||
"print(y) # [ 65 90 115 140 165]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】返回给定轴上的数组元素的累加和。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.cumsum(x)\n",
|
||||
"print(y)\n",
|
||||
"# [ 11 23 36 50 65 81 98 116 135 155 176 198 221 245 270 296 323 351\n",
|
||||
"# 380 410 441 473 506 540 575]\n",
|
||||
"\n",
|
||||
"y = np.cumsum(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 11 12 13 14 15]\n",
|
||||
"# [ 27 29 31 33 35]\n",
|
||||
"# [ 48 51 54 57 60]\n",
|
||||
"# [ 74 78 82 86 90]\n",
|
||||
"# [105 110 115 120 125]]\n",
|
||||
"\n",
|
||||
"y = np.cumsum(x, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 11 23 36 50 65]\n",
|
||||
"# [ 16 33 51 70 90]\n",
|
||||
"# [ 21 43 66 90 115]\n",
|
||||
"# [ 26 53 81 110 140]\n",
|
||||
"# [ 31 63 96 130 165]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.prod(a[, axis=None, dtype=None, out=None, …])` Return the product of array elements over a given axis.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.cumprod(a, axis=None, dtype=None, out=None)` Return the cumulative product of elements along a given axis.\n",
|
||||
"\n",
|
||||
"【例】返回给定轴上数组元素的乘积。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.prod(x)\n",
|
||||
"print(y) # 788529152\n",
|
||||
"\n",
|
||||
"y = np.prod(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [2978976 3877632 4972968 6294624 7875000]\n",
|
||||
"\n",
|
||||
"y = np.prod(x, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [ 360360 1860480 6375600 17100720 38955840]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】返回给定轴上数组元素的累乘。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.cumprod(x)\n",
|
||||
"print(y)\n",
|
||||
"# [ 11 132 1716 24024 360360 5765760\n",
|
||||
"# 98017920 1764322560 -837609728 427674624 391232512 17180672\n",
|
||||
"# 395155456 893796352 870072320 1147043840 905412608 -418250752\n",
|
||||
"# 755630080 1194065920 -1638662144 -897581056 444596224 -2063597568\n",
|
||||
"# 788529152]\n",
|
||||
"\n",
|
||||
"y = np.cumprod(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 11 12 13 14 15]\n",
|
||||
"# [ 176 204 234 266 300]\n",
|
||||
"# [ 3696 4488 5382 6384 7500]\n",
|
||||
"# [ 96096 121176 150696 185136 225000]\n",
|
||||
"# [2978976 3877632 4972968 6294624 7875000]]\n",
|
||||
"\n",
|
||||
"y = np.cumprod(x, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 11 132 1716 24024 360360]\n",
|
||||
"# [ 16 272 4896 93024 1860480]\n",
|
||||
"# [ 21 462 10626 255024 6375600]\n",
|
||||
"# [ 26 702 19656 570024 17100720]\n",
|
||||
"# [ 31 992 32736 1113024 38955840]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.diff(a, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue)` Calculate the n-th discrete difference along the given axis.\n",
|
||||
" - a：输入矩阵\n",
|
||||
" - n：可选，代表要执行几次差值\n",
|
||||
" - axis：默认是最后一个\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"The first difference is given by `out[i] = a[i+1] - a[i]` along the given axis, higher differences are calculated by using `diff` recursively.\n",
|
||||
"\n",
|
||||
"【例】沿着指定轴计算第N维的离散差值。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"A = np.arange(2, 14).reshape((3, 4))\n",
|
||||
"A[1, 1] = 8\n",
|
||||
"print(A)\n",
|
||||
"# [[ 2 3 4 5]\n",
|
||||
"# [ 6 8 8 9]\n",
|
||||
"# [10 11 12 13]]\n",
|
||||
"print(np.diff(A))\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [2 0 1]\n",
|
||||
"# [1 1 1]]\n",
|
||||
"print(np.diff(A, axis=0))\n",
|
||||
"# [[4 5 4 4]\n",
|
||||
"# [4 3 4 4]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 四舍五入\n",
|
||||
"\n",
|
||||
"- `numpy.around(a, decimals=0, out=None)` Evenly round to the given number of decimals.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】将数组舍入到给定的小数位数。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.random.rand(3, 3) * 10\n",
|
||||
"print(x)\n",
|
||||
"# [[6.59144457 3.78566113 8.15321227]\n",
|
||||
"# [1.68241475 3.78753332 7.68886328]\n",
|
||||
"# [2.84255822 9.58106727 7.86678037]]\n",
|
||||
"\n",
|
||||
"y = np.around(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 7. 4. 8.]\n",
|
||||
"# [ 2. 4. 8.]\n",
|
||||
"# [ 3. 10. 8.]]\n",
|
||||
"\n",
|
||||
"y = np.around(x, decimals=2)\n",
|
||||
"print(y)\n",
|
||||
"# [[6.59 3.79 8.15]\n",
|
||||
"# [1.68 3.79 7.69]\n",
|
||||
"# [2.84 9.58 7.87]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.ceil(x, *args, **kwargs)` Return the ceiling of the input, element-wise.\n",
|
||||
"- `numpy.floor(x, *args, **kwargs)` Return the floor of the input, element-wise.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.random.rand(3, 3) * 10\n",
|
||||
"print(x)\n",
|
||||
"# [[0.67847795 1.33073923 4.53920122]\n",
|
||||
"# [7.55724676 5.88854047 2.65502046]\n",
|
||||
"# [8.67640444 8.80110812 5.97528726]]\n",
|
||||
"\n",
|
||||
"y = np.ceil(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[1. 2. 5.]\n",
|
||||
"# [8. 6. 3.]\n",
|
||||
"# [9. 9. 6.]]\n",
|
||||
"\n",
|
||||
"y = np.floor(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[0. 1. 4.]\n",
|
||||
"# [7. 5. 2.]\n",
|
||||
"# [8. 8. 5.]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 杂项\n",
|
||||
"\n",
|
||||
"- `numpy.clip(a, a_min, a_max, out=None, **kwargs):` Clip (limit) the values in an array.\n",
|
||||
"\n",
|
||||
"Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of `[0, 1]` is specified, values smaller than 0 become 0, and values larger than 1 become 1.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】裁剪（限制）数组中的值。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.clip(x, a_min=20, a_max=30)\n",
|
||||
"print(y)\n",
|
||||
"# [[20 20 20 20 20]\n",
|
||||
"# [20 20 20 20 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [30 30 30 30 30]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.absolute(x, *args, **kwargs)` Calculate the absolute value element-wise. \n",
|
||||
"- `numpy.abs(x, *args, **kwargs)` is a shorthand for this function.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(-5, 5)\n",
|
||||
"print(x)\n",
|
||||
"# [-5 -4 -3 -2 -1 0 1 2 3 4]\n",
|
||||
"\n",
|
||||
"y = np.abs(x)\n",
|
||||
"print(y)\n",
|
||||
"# [5 4 3 2 1 0 1 2 3 4]\n",
|
||||
"\n",
|
||||
"y = np.absolute(x)\n",
|
||||
"print(y)\n",
|
||||
"# [5 4 3 2 1 0 1 2 3 4]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.sign(x, *args, **kwargs)` Returns an element-wise indication of the sign of a number.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"x = np.arange(-5, 5)\n",
|
||||
"print(x)\n",
|
||||
"#[-5 -4 -3 -2 -1 0 1 2 3 4]\n",
|
||||
"print(np.sign(x))\n",
|
||||
"#[-1 -1 -1 -1 -1 0 1 1 1 1]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"**参考文献**\n",
|
||||
"- https://mp.weixin.qq.com/s/RWsGvvmw4ptf7d8zPIDEJw\n",
|
||||
"- https://blog.csdn.net/hanshuobest/article/details/78558826?utm_medium=distribute.pc_relevant.none-task-blog-baidujs-1\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-30T17:00:33.199734Z",
|
||||
"start_time": "2020-08-30T17:00:33.194782Z"
|
||||
}
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[-5 -4 -3 -2 -1 0 1 2 3 4]\n",
|
||||
"[-1 -1 -1 -1 -1 0 1 1 1 1]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"x = np.arange(-5, 5)\n",
|
||||
"print(x)\n",
|
||||
"print(np.sign(x))"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.6.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {
|
||||
"height": "calc(100% - 180px)",
|
||||
"left": "10px",
|
||||
"top": "150px",
|
||||
"width": "307.2px"
|
||||
},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,500 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 逻辑函数\n",
|
||||
"\n",
|
||||
"## 真值测试\n",
|
||||
"\n",
|
||||
"- `numpy.all(a, axis=None, out=None, keepdims=np._NoValue)` Test whether all array elements along a given axis evaluate to True.\n",
|
||||
"- `numpy.any(a, axis=None, out=None, keepdims=np._NoValue)` Test whether any array element along a given axis evaluates to True.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.array([0, 4, 5])\n",
|
||||
"b = np.copy(a)\n",
|
||||
"print(np.all(a == b)) # True\n",
|
||||
"print(np.any(a == b)) # True\n",
|
||||
"\n",
|
||||
"b[0] = 1\n",
|
||||
"print(np.all(a == b)) # False\n",
|
||||
"print(np.any(a == b)) # True\n",
|
||||
"\n",
|
||||
"print(np.all([1.0, np.nan])) # True\n",
|
||||
"print(np.any([1.0, np.nan])) # True\n",
|
||||
"\n",
|
||||
"a = np.eye(3)\n",
|
||||
"print(np.all(a, axis=0)) # [False False False]\n",
|
||||
"print(np.any(a, axis=0)) # [ True True True]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 数组内容\n",
|
||||
"\n",
|
||||
"- `numpy.isnan(x, *args, **kwargs)` Test element-wise for NaN and return result as a boolean array.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"a=np.array([1,2,np.nan])\n",
|
||||
"print(np.isnan(a))\n",
|
||||
"#[False False True]\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 逻辑运算\n",
|
||||
"\n",
|
||||
"- `numpy.logical_not(x, *args, **kwargs)`Compute the truth value of NOT x element-wise.\n",
|
||||
"- `numpy.logical_and(x1, x2, *args, **kwargs)` Compute the truth value of x1 AND x2 element-wise.\n",
|
||||
"- `numpy.logical_or(x1, x2, *args, **kwargs)`Compute the truth value of x1 OR x2 element-wise.\n",
|
||||
"- `numpy.logical_xor(x1, x2, *args, **kwargs)`Compute the truth value of x1 XOR x2, element-wise.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"【例】计算非x元素的真值。\n",
|
||||
"\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"print(np.logical_not(3)) \n",
|
||||
"# False\n",
|
||||
"print(np.logical_not([True, False, 0, 1]))\n",
|
||||
"# [False True True False]\n",
|
||||
"\n",
|
||||
"x = np.arange(5)\n",
|
||||
"print(np.logical_not(x < 3))\n",
|
||||
"# [False False False True True]\n",
|
||||
"\n",
|
||||
"【例】计算x1 AND x2元素的真值。\n",
|
||||
"\n",
|
||||
"print(np.logical_and(True, False)) \n",
|
||||
"# False\n",
|
||||
"print(np.logical_and([True, False], [True, False]))\n",
|
||||
"# [ True False]\n",
|
||||
"print(np.logical_and(x > 1, x < 4))\n",
|
||||
"# [False False True True False]\n",
|
||||
"\n",
|
||||
"【例】逐元素计算x1 OR x2的真值。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"print(np.logical_or(True, False))\n",
|
||||
"# True\n",
|
||||
"print(np.logical_or([True, False], [False, False]))\n",
|
||||
"# [ True False]\n",
|
||||
"print(np.logical_or(x < 1, x > 3))\n",
|
||||
"# [ True False False False True]\n",
|
||||
"\n",
|
||||
"【例】计算x1 XOR x2的真值，按元素计算。\n",
|
||||
"\n",
|
||||
"print(np.logical_xor(True, False))\n",
|
||||
"# True\n",
|
||||
"print(np.logical_xor([True, True, False, False], [True, False, True, False]))\n",
|
||||
"# [False True True False]\n",
|
||||
"print(np.logical_xor(x < 1, x > 3))\n",
|
||||
"# [ True False False False True]\n",
|
||||
"print(np.logical_xor(0, np.eye(2)))\n",
|
||||
"# [[ True False]\n",
|
||||
"# [False True]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 对照\n",
|
||||
"\n",
|
||||
"- `numpy.greater(x1, x2, *args, **kwargs)` Return the truth value of (x1 > x2) element-wise.\n",
|
||||
"- `numpy.greater_equal(x1, x2, *args, **kwargs)` Return the truth value of (x1 >= x2) element-wise.\n",
|
||||
"- `numpy.equal(x1, x2, *args, **kwargs)` Return (x1 == x2) element-wise.\n",
|
||||
"- `numpy.not_equal(x1, x2, *args, **kwargs)` Return (x1 != x2) element-wise.\n",
|
||||
"- `numpy.less(x1, x2, *args, **kwargs)` Return the truth value of (x1 < x2) element-wise.\n",
|
||||
"- `numpy.less_equal(x1, x2, *args, **kwargs)` Return the truth value of (x1 =< x2) element-wise.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】numpy对以上对照函数进行了运算符的重载。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"\n",
|
||||
"y = x > 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.greater(x, 2))\n",
|
||||
"# [False False True True True True True True]\n",
|
||||
"\n",
|
||||
"y = x >= 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.greater_equal(x, 2))\n",
|
||||
"# [False True True True True True True True]\n",
|
||||
"\n",
|
||||
"y = x == 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.equal(x, 2))\n",
|
||||
"# [False True False False False False False False]\n",
|
||||
"\n",
|
||||
"y = x != 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.not_equal(x, 2))\n",
|
||||
"# [ True False True True True True True True]\n",
|
||||
"\n",
|
||||
"y = x < 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.less(x, 2))\n",
|
||||
"# [ True False False False False False False False]\n",
|
||||
"\n",
|
||||
"y = x <= 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.less_equal(x, 2))\n",
|
||||
"# [ True True False False False False False False]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = x > 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.greater(x, 20))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]]\n",
|
||||
"\n",
|
||||
"y = x >= 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.greater_equal(x, 20))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]]\n",
|
||||
"\n",
|
||||
"y = x == 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.equal(x, 20))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False True]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]]\n",
|
||||
"\n",
|
||||
"y = x != 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.not_equal(x, 20))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True False]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]]\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"y = x < 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.less(x, 20))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]]\n",
|
||||
"\n",
|
||||
"y = x <= 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.less_equal(x, 20))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(20200611)\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"y = np.random.randint(10, 40, [5, 5])\n",
|
||||
"print(y)\n",
|
||||
"# [[32 28 31 33 37]\n",
|
||||
"# [23 37 37 30 29]\n",
|
||||
"# [32 24 10 33 15]\n",
|
||||
"# [27 17 10 36 16]\n",
|
||||
"# [25 32 23 39 34]]\n",
|
||||
"\n",
|
||||
"z = x > y\n",
|
||||
"print(z)\n",
|
||||
"print(np.greater(x, y))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False True False True]\n",
|
||||
"# [False True True False True]\n",
|
||||
"# [ True False True False True]]\n",
|
||||
"\n",
|
||||
"z = x >= y\n",
|
||||
"print(z)\n",
|
||||
"print(np.greater_equal(x, y))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False True False True]\n",
|
||||
"# [False True True False True]\n",
|
||||
"# [ True True True False True]]\n",
|
||||
"\n",
|
||||
"z = x == y\n",
|
||||
"print(z)\n",
|
||||
"print(np.equal(x, y))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False True False False False]]\n",
|
||||
"\n",
|
||||
"z = x != y\n",
|
||||
"print(z)\n",
|
||||
"print(np.not_equal(x, y))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True False True True True]]\n",
|
||||
"\n",
|
||||
"z = x < y\n",
|
||||
"print(z)\n",
|
||||
"print(np.less(x, y))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True False True False]\n",
|
||||
"# [ True False False True False]\n",
|
||||
"# [False False False True False]]\n",
|
||||
"\n",
|
||||
"z = x <= y\n",
|
||||
"print(z)\n",
|
||||
"print(np.less_equal(x, y))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True False True False]\n",
|
||||
"# [ True False False True False]\n",
|
||||
"# [False True False True False]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】注意 numpy 的广播规则。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"np.random.seed(20200611)\n",
|
||||
"y = np.random.randint(10, 50, 5)\n",
|
||||
"\n",
|
||||
"print(y)\n",
|
||||
"# [32 37 30 24 10]\n",
|
||||
"\n",
|
||||
"z = x > y\n",
|
||||
"print(z)\n",
|
||||
"print(np.greater(x, y))\n",
|
||||
"# [[False False False False True]\n",
|
||||
"# [False False False False True]\n",
|
||||
"# [False False False False True]\n",
|
||||
"# [False False False True True]\n",
|
||||
"# [False False True True True]]\n",
|
||||
"\n",
|
||||
"z = x >= y\n",
|
||||
"print(z)\n",
|
||||
"print(np.greater_equal(x, y))\n",
|
||||
"# [[False False False False True]\n",
|
||||
"# [False False False False True]\n",
|
||||
"# [False False False True True]\n",
|
||||
"# [False False False True True]\n",
|
||||
"# [False False True True True]]\n",
|
||||
"\n",
|
||||
"z = x == y\n",
|
||||
"print(z)\n",
|
||||
"print(np.equal(x, y))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False True False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]]\n",
|
||||
"\n",
|
||||
"z = x != y\n",
|
||||
"print(z)\n",
|
||||
"print(np.not_equal(x, y))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True False True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]]\n",
|
||||
"\n",
|
||||
"z = x < y\n",
|
||||
"print(z)\n",
|
||||
"print(np.less(x, y))\n",
|
||||
"# [[ True True True True False]\n",
|
||||
"# [ True True True True False]\n",
|
||||
"# [ True True True False False]\n",
|
||||
"# [ True True True False False]\n",
|
||||
"# [ True True False False False]]\n",
|
||||
"\n",
|
||||
"z = x <= y\n",
|
||||
"print(z)\n",
|
||||
"print(np.less_equal(x, y))\n",
|
||||
"# [[ True True True True False]\n",
|
||||
"# [ True True True True False]\n",
|
||||
"# [ True True True True False]\n",
|
||||
"# [ True True True False False]\n",
|
||||
"# [ True True False False False]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)` Returns a boolean array where two arrays are element-wise equal within a tolerance.\n",
|
||||
"- `numpy.allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)` Returns True if two arrays are element-wise equal within a tolerance. \n",
|
||||
"\n",
|
||||
"`numpy.allclose()` 等价于 `numpy.all(isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan))`。\n",
|
||||
"\n",
|
||||
"The tolerance values are positive, typically very small numbers. The relative difference (`rtol * abs(b)`) and the absolute difference `atol` are added together to compare against the absolute difference between `a` and `b`.\n",
|
||||
"\n",
|
||||
"判断是否为True的计算依据：\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"np.absolute(a - b) <= (atol + rtol * absolute(b))\n",
|
||||
"\n",
|
||||
"- atol：float，绝对公差。\n",
|
||||
"- rtol：float，相对公差。\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"NaNs are treated as equal if they are in the same place and if `equal_nan=True`. Infs are treated as equal if they are in the same place and of the same sign in both arrays.\n",
|
||||
"\n",
|
||||
"【例】比较两个数组是否可以认为相等。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.isclose([1e10, 1e-7], [1.00001e10, 1e-8])\n",
|
||||
"print(x) # [ True False]\n",
|
||||
"\n",
|
||||
"x = np.allclose([1e10, 1e-7], [1.00001e10, 1e-8])\n",
|
||||
"print(x) # False\n",
|
||||
"\n",
|
||||
"x = np.isclose([1e10, 1e-8], [1.00001e10, 1e-9])\n",
|
||||
"print(x) # [ True True]\n",
|
||||
"\n",
|
||||
"x = np.allclose([1e10, 1e-8], [1.00001e10, 1e-9])\n",
|
||||
"print(x) # True\n",
|
||||
"\n",
|
||||
"x = np.isclose([1e10, 1e-8], [1.0001e10, 1e-9])\n",
|
||||
"print(x) # [False True]\n",
|
||||
"\n",
|
||||
"x = np.allclose([1e10, 1e-8], [1.0001e10, 1e-9])\n",
|
||||
"print(x) # False\n",
|
||||
"\n",
|
||||
"x = np.isclose([1.0, np.nan], [1.0, np.nan])\n",
|
||||
"print(x) # [ True False]\n",
|
||||
"\n",
|
||||
"x = np.allclose([1.0, np.nan], [1.0, np.nan])\n",
|
||||
"print(x) # False\n",
|
||||
"\n",
|
||||
"x = np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)\n",
|
||||
"print(x) # [ True True]\n",
|
||||
"\n",
|
||||
"x = np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)\n",
|
||||
"print(x) # True\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.6.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,828 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 排序，搜索和计数\n",
|
||||
"## 排序\n",
|
||||
"\n",
|
||||
"- `numpy.sort(a[, axis=-1, kind='quicksort', order=None])` Return a sorted **copy** of an array.\n",
|
||||
" - axis：排序沿数组的（轴）方向，0表示按行，1表示按列，None表示展开来排序，默认为-1，表示沿最后的轴排序。\n",
|
||||
" - kind：排序的算法，提供了快排'quicksort'、混排'mergesort'、堆排'heapsort'， 默认为‘quicksort'。\n",
|
||||
" - order：排序的字段名，可指定字段排序，默认为None。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(20200612)\n",
|
||||
"x = np.random.rand(5, 5) * 10\n",
|
||||
"x = np.around(x, 2)\n",
|
||||
"print(x)\n",
|
||||
"# [[2.32 7.54 9.78 1.73 6.22]\n",
|
||||
"# [6.93 5.17 9.28 9.76 8.25]\n",
|
||||
"# [0.01 4.23 0.19 1.73 9.27]\n",
|
||||
"# [7.99 4.97 0.88 7.32 4.29]\n",
|
||||
"# [9.05 0.07 8.95 7.9 6.99]]\n",
|
||||
"\n",
|
||||
"y = np.sort(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[1.73 2.32 6.22 7.54 9.78]\n",
|
||||
"# [5.17 6.93 8.25 9.28 9.76]\n",
|
||||
"# [0.01 0.19 1.73 4.23 9.27]\n",
|
||||
"# [0.88 4.29 4.97 7.32 7.99]\n",
|
||||
"# [0.07 6.99 7.9 8.95 9.05]]\n",
|
||||
"\n",
|
||||
"y = np.sort(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[0.01 0.07 0.19 1.73 4.29]\n",
|
||||
"# [2.32 4.23 0.88 1.73 6.22]\n",
|
||||
"# [6.93 4.97 8.95 7.32 6.99]\n",
|
||||
"# [7.99 5.17 9.28 7.9 8.25]\n",
|
||||
"# [9.05 7.54 9.78 9.76 9.27]]\n",
|
||||
"\n",
|
||||
"y = np.sort(x, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [[1.73 2.32 6.22 7.54 9.78]\n",
|
||||
"# [5.17 6.93 8.25 9.28 9.76]\n",
|
||||
"# [0.01 0.19 1.73 4.23 9.27]\n",
|
||||
"# [0.88 4.29 4.97 7.32 7.99]\n",
|
||||
"# [0.07 6.99 7.9 8.95 9.05]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"dt = np.dtype([('name', 'S10'), ('age', np.int)])\n",
|
||||
"a = np.array([(\"Mike\", 21), (\"Nancy\", 25), (\"Bob\", 17), (\"Jane\", 27)], dtype=dt)\n",
|
||||
"b = np.sort(a, order='name')\n",
|
||||
"print(b)\n",
|
||||
"# [(b'Bob', 17) (b'Jane', 27) (b'Mike', 21) (b'Nancy', 25)]\n",
|
||||
"\n",
|
||||
"b = np.sort(a, order='age')\n",
|
||||
"print(b)\n",
|
||||
"# [(b'Bob', 17) (b'Mike', 21) (b'Nancy', 25) (b'Jane', 27)]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"如果排序后，想用元素的索引位置替代排序后的实际结果，该怎么办呢？\n",
|
||||
"\n",
|
||||
"- `numpy.argsort(a[, axis=-1, kind='quicksort', order=None])` Returns the indices that would sort an array.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】对数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组。这个索引数组用于构造排序后的数组。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(20200612)\n",
|
||||
"x = np.random.randint(0, 10, 10)\n",
|
||||
"print(x)\n",
|
||||
"# [6 1 8 5 5 4 1 2 9 1]\n",
|
||||
"\n",
|
||||
"y = np.argsort(x)\n",
|
||||
"print(y)\n",
|
||||
"# [1 6 9 7 5 3 4 0 2 8]\n",
|
||||
"\n",
|
||||
"print(x[y])\n",
|
||||
"# [1 1 1 2 4 5 5 6 8 9]\n",
|
||||
"\n",
|
||||
"y = np.argsort(-x)\n",
|
||||
"print(y)\n",
|
||||
"# [8 2 0 3 4 5 7 1 6 9]\n",
|
||||
"\n",
|
||||
"print(x[y])\n",
|
||||
"# [9 8 6 5 5 4 2 1 1 1]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(20200612)\n",
|
||||
"x = np.random.rand(5, 5) * 10\n",
|
||||
"x = np.around(x, 2)\n",
|
||||
"print(x)\n",
|
||||
"# [[2.32 7.54 9.78 1.73 6.22]\n",
|
||||
"# [6.93 5.17 9.28 9.76 8.25]\n",
|
||||
"# [0.01 4.23 0.19 1.73 9.27]\n",
|
||||
"# [7.99 4.97 0.88 7.32 4.29]\n",
|
||||
"# [9.05 0.07 8.95 7.9 6.99]]\n",
|
||||
"\n",
|
||||
"y = np.argsort(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[3 0 4 1 2]\n",
|
||||
"# [1 0 4 2 3]\n",
|
||||
"# [0 2 3 1 4]\n",
|
||||
"# [2 4 1 3 0]\n",
|
||||
"# [1 4 3 2 0]]\n",
|
||||
"\n",
|
||||
"y = np.argsort(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[2 4 2 0 3]\n",
|
||||
"# [0 2 3 2 0]\n",
|
||||
"# [1 3 4 3 4]\n",
|
||||
"# [3 1 1 4 1]\n",
|
||||
"# [4 0 0 1 2]]\n",
|
||||
"\n",
|
||||
"y = np.argsort(x, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [[3 0 4 1 2]\n",
|
||||
"# [1 0 4 2 3]\n",
|
||||
"# [0 2 3 1 4]\n",
|
||||
"# [2 4 1 3 0]\n",
|
||||
"# [1 4 3 2 0]]\n",
|
||||
"\n",
|
||||
"y = np.array([np.take(x[i], np.argsort(x[i])) for i in range(5)]) \n",
|
||||
"#numpy.take(a, indices, axis=None, out=None, mode='raise')沿轴从数组中获取元素。\n",
|
||||
"print(y)\n",
|
||||
"# [[1.73 2.32 6.22 7.54 9.78]\n",
|
||||
"# [5.17 6.93 8.25 9.28 9.76]\n",
|
||||
"# [0.01 0.19 1.73 4.23 9.27]\n",
|
||||
"# [0.88 4.29 4.97 7.32 7.99]\n",
|
||||
"# [0.07 6.99 7.9 8.95 9.05]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"如何将数据按照某一指标进行排序呢？\n",
|
||||
"\n",
|
||||
"- `numpy.lexsort(keys[, axis=-1])` Perform an indirect stable sort using a sequence of keys.（使用键序列执行间接稳定排序。）\n",
|
||||
"\n",
|
||||
"- 给定多个可以在电子表格中解释为列的排序键，lexsort返回一个整数索引数组，该数组描述了按多个列排序的顺序。序列中的最后一个键用于主排序顺序，倒数第二个键用于辅助排序顺序，依此类推。keys参数必须是可以转换为相同形状的数组的对象序列。如果为keys参数提供了2D数组，则将其行解释为排序键，并根据最后一行，倒数第二行等进行排序。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】按照第一列的升序或者降序对整体数据进行排序。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(20200612)\n",
|
||||
"x = np.random.rand(5, 5) * 10\n",
|
||||
"x = np.around(x, 2)\n",
|
||||
"print(x)\n",
|
||||
"# [[2.32 7.54 9.78 1.73 6.22]\n",
|
||||
"# [6.93 5.17 9.28 9.76 8.25]\n",
|
||||
"# [0.01 4.23 0.19 1.73 9.27]\n",
|
||||
"# [7.99 4.97 0.88 7.32 4.29]\n",
|
||||
"# [9.05 0.07 8.95 7.9 6.99]]\n",
|
||||
"\n",
|
||||
"index = np.lexsort([x[:, 0]])\n",
|
||||
"print(index)\n",
|
||||
"# [2 0 1 3 4]\n",
|
||||
"\n",
|
||||
"y = x[index]\n",
|
||||
"print(y)\n",
|
||||
"# [[0.01 4.23 0.19 1.73 9.27]\n",
|
||||
"# [2.32 7.54 9.78 1.73 6.22]\n",
|
||||
"# [6.93 5.17 9.28 9.76 8.25]\n",
|
||||
"# [7.99 4.97 0.88 7.32 4.29]\n",
|
||||
"# [9.05 0.07 8.95 7.9 6.99]]\n",
|
||||
"\n",
|
||||
"index = np.lexsort([-1 * x[:, 0]])\n",
|
||||
"print(index)\n",
|
||||
"# [4 3 1 0 2]\n",
|
||||
"\n",
|
||||
"y = x[index]\n",
|
||||
"print(y)\n",
|
||||
"# [[9.05 0.07 8.95 7.9 6.99]\n",
|
||||
"# [7.99 4.97 0.88 7.32 4.29]\n",
|
||||
"# [6.93 5.17 9.28 9.76 8.25]\n",
|
||||
"# [2.32 7.54 9.78 1.73 6.22]\n",
|
||||
"# [0.01 4.23 0.19 1.73 9.27]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 5, 1, 4, 3, 4, 4])\n",
|
||||
"y = np.array([9, 4, 0, 4, 0, 2, 1])\n",
|
||||
"a = np.lexsort([x])\n",
|
||||
"b = np.lexsort([y])\n",
|
||||
"print(a)\n",
|
||||
"# [0 2 4 3 5 6 1]\n",
|
||||
"print(x[a])\n",
|
||||
"# [1 1 3 4 4 4 5]\n",
|
||||
"\n",
|
||||
"print(b)\n",
|
||||
"# [2 4 6 5 1 3 0]\n",
|
||||
"print(y[b])\n",
|
||||
"# [0 0 1 2 4 4 9]\n",
|
||||
"\n",
|
||||
"z = np.lexsort([y, x])\n",
|
||||
"print(z)\n",
|
||||
"# [2 0 4 6 5 3 1]\n",
|
||||
"print(x[z])\n",
|
||||
"# [1 1 3 4 4 4 5]\n",
|
||||
"\n",
|
||||
"z = np.lexsort([x, y])\n",
|
||||
"print(z)\n",
|
||||
"# [2 4 6 5 3 1 0]\n",
|
||||
"print(y[z])\n",
|
||||
"# [0 0 1 2 4 4 9]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.partition(a, kth, axis=-1, kind='introselect', order=None)` Return a partitioned copy of an array.\n",
|
||||
"\n",
|
||||
"Creates a copy of the array with its elements rearranged in such a way that the value of the element in k-th position is in the position it would be in a sorted array. All elements smaller than the k-th element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undefined.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】以索引是 kth 的元素为基准，将元素分成两部分，即大于该元素的放在其后面，小于该元素的放在其前面，这里有点类似于快排。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(100)\n",
|
||||
"x = np.random.randint(1, 30, [8, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[ 9 25 4]\n",
|
||||
"# [ 8 24 16]\n",
|
||||
"# [17 11 21]\n",
|
||||
"# [ 3 22 3]\n",
|
||||
"# [ 3 15 3]\n",
|
||||
"# [18 17 25]\n",
|
||||
"# [16 5 12]\n",
|
||||
"# [29 27 17]]\n",
|
||||
"\n",
|
||||
"y = np.sort(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 3 5 3]\n",
|
||||
"# [ 3 11 3]\n",
|
||||
"# [ 8 15 4]\n",
|
||||
"# [ 9 17 12]\n",
|
||||
"# [16 22 16]\n",
|
||||
"# [17 24 17]\n",
|
||||
"# [18 25 21]\n",
|
||||
"# [29 27 25]]\n",
|
||||
"\n",
|
||||
"z = np.partition(x, kth=2, axis=0)\n",
|
||||
"print(z)\n",
|
||||
"# [[ 3 5 3]\n",
|
||||
"# [ 3 11 3]\n",
|
||||
"# [ 8 15 4]\n",
|
||||
"# [ 9 22 21]\n",
|
||||
"# [17 24 16]\n",
|
||||
"# [18 17 25]\n",
|
||||
"# [16 25 12]\n",
|
||||
"# [29 27 17]]\n",
|
||||
"```\n",
|
||||
"【例】选取每一列第三小的数\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(100)\n",
|
||||
"x = np.random.randint(1, 30, [8, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[ 9 25 4]\n",
|
||||
"# [ 8 24 16]\n",
|
||||
"# [17 11 21]\n",
|
||||
"# [ 3 22 3]\n",
|
||||
"# [ 3 15 3]\n",
|
||||
"# [18 17 25]\n",
|
||||
"# [16 5 12]\n",
|
||||
"# [29 27 17]]\n",
|
||||
"z = np.partition(x, kth=2, axis=0)\n",
|
||||
"print(z[2])\n",
|
||||
"# [ 8 15 4]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】选取每一列第三大的数据\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(100)\n",
|
||||
"x = np.random.randint(1, 30, [8, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[ 9 25 4]\n",
|
||||
"# [ 8 24 16]\n",
|
||||
"# [17 11 21]\n",
|
||||
"# [ 3 22 3]\n",
|
||||
"# [ 3 15 3]\n",
|
||||
"# [18 17 25]\n",
|
||||
"# [16 5 12]\n",
|
||||
"# [29 27 17]]\n",
|
||||
"z = np.partition(x, kth=-3, axis=0)\n",
|
||||
"print(z[-3])\n",
|
||||
"# [17 24 17]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.argpartition(a, kth, axis=-1, kind='introselect', order=None)`\n",
|
||||
"\n",
|
||||
"Perform an indirect partition along the given axis using the algorithm specified by the `kind` keyword. It returns an array of indices of the same shape as `a` that index data along the given axis in partitioned order.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(100)\n",
|
||||
"x = np.random.randint(1, 30, [8, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[ 9 25 4]\n",
|
||||
"# [ 8 24 16]\n",
|
||||
"# [17 11 21]\n",
|
||||
"# [ 3 22 3]\n",
|
||||
"# [ 3 15 3]\n",
|
||||
"# [18 17 25]\n",
|
||||
"# [16 5 12]\n",
|
||||
"# [29 27 17]]\n",
|
||||
"\n",
|
||||
"y = np.argsort(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[3 6 3]\n",
|
||||
"# [4 2 4]\n",
|
||||
"# [1 4 0]\n",
|
||||
"# [0 5 6]\n",
|
||||
"# [6 3 1]\n",
|
||||
"# [2 1 7]\n",
|
||||
"# [5 0 2]\n",
|
||||
"# [7 7 5]]\n",
|
||||
"\n",
|
||||
"z = np.argpartition(x, kth=2, axis=0)\n",
|
||||
"print(z)\n",
|
||||
"# [[3 6 3]\n",
|
||||
"# [4 2 4]\n",
|
||||
"# [1 4 0]\n",
|
||||
"# [0 3 2]\n",
|
||||
"# [2 1 1]\n",
|
||||
"# [5 5 5]\n",
|
||||
"# [6 0 6]\n",
|
||||
"# [7 7 7]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】选取每一列第三小的数的索引\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(100)\n",
|
||||
"x = np.random.randint(1, 30, [8, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[ 9 25 4]\n",
|
||||
"# [ 8 24 16]\n",
|
||||
"# [17 11 21]\n",
|
||||
"# [ 3 22 3]\n",
|
||||
"# [ 3 15 3]\n",
|
||||
"# [18 17 25]\n",
|
||||
"# [16 5 12]\n",
|
||||
"# [29 27 17]]\n",
|
||||
"\n",
|
||||
"z = np.argpartition(x, kth=2, axis=0)\n",
|
||||
"print(z[2])\n",
|
||||
"# [1 4 0]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】选取每一列第三大的数的索引\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(100)\n",
|
||||
"x = np.random.randint(1, 30, [8, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[ 9 25 4]\n",
|
||||
"# [ 8 24 16]\n",
|
||||
"# [17 11 21]\n",
|
||||
"# [ 3 22 3]\n",
|
||||
"# [ 3 15 3]\n",
|
||||
"# [18 17 25]\n",
|
||||
"# [16 5 12]\n",
|
||||
"# [29 27 17]]\n",
|
||||
"\n",
|
||||
"z = np.argpartition(x, kth=-3, axis=0)\n",
|
||||
"print(z[-3])\n",
|
||||
"# [2 1 7]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 搜索\n",
|
||||
"\n",
|
||||
"- `numpy.argmax(a[, axis=None, out=None])`Returns the indices of the maximum values along an axis.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(20200612)\n",
|
||||
"x = np.random.rand(5, 5) * 10\n",
|
||||
"x = np.around(x, 2)\n",
|
||||
"print(x)\n",
|
||||
"# [[2.32 7.54 9.78 1.73 6.22]\n",
|
||||
"# [6.93 5.17 9.28 9.76 8.25]\n",
|
||||
"# [0.01 4.23 0.19 1.73 9.27]\n",
|
||||
"# [7.99 4.97 0.88 7.32 4.29]\n",
|
||||
"# [9.05 0.07 8.95 7.9 6.99]]\n",
|
||||
"\n",
|
||||
"y = np.argmax(x)\n",
|
||||
"print(y) # 2\n",
|
||||
"\n",
|
||||
"y = np.argmax(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [4 0 0 1 2]\n",
|
||||
"\n",
|
||||
"y = np.argmax(x, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [2 3 4 0 0]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.argmin(a[, axis=None, out=None])`Returns the indices of the minimum values along an axis.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(20200612)\n",
|
||||
"x = np.random.rand(5, 5) * 10\n",
|
||||
"x = np.around(x, 2)\n",
|
||||
"print(x)\n",
|
||||
"# [[2.32 7.54 9.78 1.73 6.22]\n",
|
||||
"# [6.93 5.17 9.28 9.76 8.25]\n",
|
||||
"# [0.01 4.23 0.19 1.73 9.27]\n",
|
||||
"# [7.99 4.97 0.88 7.32 4.29]\n",
|
||||
"# [9.05 0.07 8.95 7.9 6.99]]\n",
|
||||
"\n",
|
||||
"y = np.argmin(x)\n",
|
||||
"print(y) # 10\n",
|
||||
"\n",
|
||||
"y = np.argmin(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [2 4 2 0 3]\n",
|
||||
"\n",
|
||||
"y = np.argmin(x, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [3 1 0 2 1]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numppy.nonzero(a)` Return the indices of the elements that are non-zero.\n",
|
||||
"\n",
|
||||
"，其值为非零元素的下标在对应轴上的值。\n",
|
||||
"\n",
|
||||
"1. 只有`a`中非零元素才会有索引值，那些零值元素没有索引值。\n",
|
||||
"2. 返回一个长度为`a.ndim`的元组（tuple），元组的每个元素都是一个整数数组（array）。\n",
|
||||
"3. 每一个array均是从一个维度上来描述其索引值。比如，如果`a`是一个二维数组，则tuple包含两个array，第一个array从行维度来描述索引值；第二个array从列维度来描述索引值。\n",
|
||||
"4. 该 `np.transpose(np.nonzero(x))` 函数能够描述出每一个非零元素在不同维度的索引值。\n",
|
||||
"5. 通过`a[nonzero(a)]`得到所有`a`中的非零值。\n",
|
||||
"\n",
|
||||
"【例】一维数组\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([0, 2, 3])\n",
|
||||
"print(x) # [0 2 3]\n",
|
||||
"print(x.shape) # (3,)\n",
|
||||
"print(x.ndim) # 1\n",
|
||||
"\n",
|
||||
"y = np.nonzero(x)\n",
|
||||
"print(y) # (array([1, 2], dtype=int64),)\n",
|
||||
"print(np.array(y)) # [[1 2]]\n",
|
||||
"print(np.array(y).shape) # (1, 2)\n",
|
||||
"print(np.array(y).ndim) # 2\n",
|
||||
"print(np.transpose(y))\n",
|
||||
"# [[1]\n",
|
||||
"# [2]]\n",
|
||||
"print(x[np.nonzero(x)])\n",
|
||||
"#[2, 3]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】二维数组\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])\n",
|
||||
"print(x)\n",
|
||||
"# [[3 0 0]\n",
|
||||
"# [0 4 0]\n",
|
||||
"# [5 6 0]]\n",
|
||||
"print(x.shape) # (3, 3)\n",
|
||||
"print(x.ndim) # 2\n",
|
||||
"\n",
|
||||
"y = np.nonzero(x)\n",
|
||||
"print(y)\n",
|
||||
"# (array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))\n",
|
||||
"print(np.array(y))\n",
|
||||
"# [[0 1 2 2]\n",
|
||||
"# [0 1 0 1]]\n",
|
||||
"print(np.array(y).shape) # (2, 4)\n",
|
||||
"print(np.array(y).ndim) # 2\n",
|
||||
"\n",
|
||||
"y = x[np.nonzero(x)]\n",
|
||||
"print(y) # [3 4 5 6]\n",
|
||||
"\n",
|
||||
"y = np.transpose(np.nonzero(x))\n",
|
||||
"print(y)\n",
|
||||
"# [[0 0]\n",
|
||||
"# [1 1]\n",
|
||||
"# [2 0]\n",
|
||||
"# [2 1]]\n",
|
||||
"```\n",
|
||||
"【例】三维数组\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[[0, 1], [1, 0]], [[0, 1], [1, 0]], [[0, 0], [1, 0]]])\n",
|
||||
"print(x)\n",
|
||||
"# [[[0 1]\n",
|
||||
"# [1 0]]\n",
|
||||
"#\n",
|
||||
"# [[0 1]\n",
|
||||
"# [1 0]]\n",
|
||||
"#\n",
|
||||
"# [[0 0]\n",
|
||||
"# [1 0]]]\n",
|
||||
"print(np.shape(x)) # (3, 2, 2)\n",
|
||||
"print(x.ndim) # 3\n",
|
||||
"\n",
|
||||
"y = np.nonzero(x)\n",
|
||||
"print(np.array(y))\n",
|
||||
"# [[0 0 1 1 2]\n",
|
||||
"# [0 1 0 1 1]\n",
|
||||
"# [1 0 1 0 0]]\n",
|
||||
"print(np.array(y).shape) # (3, 5)\n",
|
||||
"print(np.array(y).ndim) # 2\n",
|
||||
"print(y)\n",
|
||||
"# (array([0, 0, 1, 1, 2], dtype=int64), array([0, 1, 0, 1, 1], dtype=int64), array([1, 0, 1, 0, 0], dtype=int64))\n",
|
||||
"print(x[np.nonzero(x)])\n",
|
||||
"#[1 1 1 1 1]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】`nonzero()`将布尔数组转换成整数数组进行操作。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
|
||||
"print(x)\n",
|
||||
"# [[1 2 3]\n",
|
||||
"# [4 5 6]\n",
|
||||
"# [7 8 9]]\n",
|
||||
"\n",
|
||||
"y = x > 3\n",
|
||||
"print(y)\n",
|
||||
"# [[False False False]\n",
|
||||
"# [ True True True]\n",
|
||||
"# [ True True True]]\n",
|
||||
"\n",
|
||||
"y = np.nonzero(x > 3)\n",
|
||||
"print(y)\n",
|
||||
"# (array([1, 1, 1, 2, 2, 2], dtype=int64), array([0, 1, 2, 0, 1, 2], dtype=int64))\n",
|
||||
"\n",
|
||||
"y = x[np.nonzero(x > 3)]\n",
|
||||
"print(y)\n",
|
||||
"# [4 5 6 7 8 9]\n",
|
||||
"\n",
|
||||
"y = x[x > 3]\n",
|
||||
"print(y)\n",
|
||||
"# [4 5 6 7 8 9]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.where(condition, [x=None, y=None])` Return elements chosen from `x` or `y` depending on `condition`.\n",
|
||||
"\n",
|
||||
"【例】满足条件`condition`，输出`x`，不满足输出`y`。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(10)\n",
|
||||
"print(x)\n",
|
||||
"# [0 1 2 3 4 5 6 7 8 9]\n",
|
||||
"\n",
|
||||
"y = np.where(x < 5, x, 10 * x)\n",
|
||||
"print(y)\n",
|
||||
"# [ 0 1 2 3 4 50 60 70 80 90]\n",
|
||||
"\n",
|
||||
"x = np.array([[0, 1, 2],\n",
|
||||
" [0, 2, 4],\n",
|
||||
" [0, 3, 6]])\n",
|
||||
"y = np.where(x < 4, x, -1)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 0 1 2]\n",
|
||||
"# [ 0 2 -1]\n",
|
||||
"# [ 0 3 -1]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】只有`condition`，没有`x`和`y`，则输出满足条件 (即非0) 元素的坐标 (等价于`numpy.nonzero`)。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"y = np.where(x > 5)\n",
|
||||
"print(y)\n",
|
||||
"# (array([5, 6, 7], dtype=int64),)\n",
|
||||
"print(x[y])\n",
|
||||
"# [6 7 8]\n",
|
||||
"\n",
|
||||
"y = np.nonzero(x > 5)\n",
|
||||
"print(y)\n",
|
||||
"# (array([5, 6, 7], dtype=int64),)\n",
|
||||
"print(x[y])\n",
|
||||
"# [6 7 8]\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.where(x > 25)\n",
|
||||
"print(y)\n",
|
||||
"# (array([3, 3, 3, 3, 3, 4, 4, 4, 4, 4], dtype=int64), array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4], dtype=int64))\n",
|
||||
"\n",
|
||||
"print(x[y])\n",
|
||||
"# [26 27 28 29 30 31 32 33 34 35]\n",
|
||||
"\n",
|
||||
"y = np.nonzero(x > 25)\n",
|
||||
"print(y)\n",
|
||||
"# (array([3, 3, 3, 3, 3, 4, 4, 4, 4, 4], dtype=int64), array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4], dtype=int64))\n",
|
||||
"print(x[y])\n",
|
||||
"# [26 27 28 29 30 31 32 33 34 35]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.searchsorted(a, v[, side='left', sorter=None])` Find indices where elements should be inserted to maintain order.\n",
|
||||
" - a：一维输入数组。当`sorter`参数为`None`的时候，`a`必须为升序数组；否则，`sorter`不能为空，存放`a`中元素的`index`，用于反映`a`数组的升序排列方式。\n",
|
||||
" - v：插入`a`数组的值，可以为单个元素，`list`或者`ndarray`。\n",
|
||||
" - side：查询方向，当为`left`时，将返回第一个符合条件的元素下标；当为`right`时，将返回最后一个符合条件的元素下标。\n",
|
||||
" - sorter：一维数组存放`a`数组元素的 index，index 对应元素为升序。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([0, 1, 5, 9, 11, 18, 26, 33])\n",
|
||||
"y = np.searchsorted(x, 15)\n",
|
||||
"print(y) # 5\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, 15, side='right')\n",
|
||||
"print(y) # 5\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, -1)\n",
|
||||
"print(y) # 0\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, -1, side='right')\n",
|
||||
"print(y) # 0\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, 35)\n",
|
||||
"print(y) # 8\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, 35, side='right')\n",
|
||||
"print(y) # 8\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, 11)\n",
|
||||
"print(y) # 4\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, 11, side='right')\n",
|
||||
"print(y) # 5\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, 0)\n",
|
||||
"print(y) # 0\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, 0, side='right')\n",
|
||||
"print(y) # 1\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, 33)\n",
|
||||
"print(y) # 7\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, 33, side='right')\n",
|
||||
"print(y) # 8\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([0, 1, 5, 9, 11, 18, 26, 33])\n",
|
||||
"y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35])\n",
|
||||
"print(y) # [0 0 4 5 7 8]\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], side='right')\n",
|
||||
"print(y) # [0 1 5 5 8 8]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([0, 1, 5, 9, 11, 18, 26, 33])\n",
|
||||
"np.random.shuffle(x)\n",
|
||||
"print(x) # [33 1 9 18 11 26 0 5]\n",
|
||||
"\n",
|
||||
"x_sort = np.argsort(x)\n",
|
||||
"print(x_sort) # [6 1 7 2 4 3 5 0]\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], sorter=x_sort)\n",
|
||||
"print(y) # [0 0 4 5 7 8]\n",
|
||||
"\n",
|
||||
"y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], side='right', sorter=x_sort)\n",
|
||||
"print(y) # [0 1 5 5 8 8]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 计数\n",
|
||||
"\n",
|
||||
"- `numpy.count_nonzero(a, axis=None)` Counts the number of non-zero values in the array a.\n",
|
||||
"\n",
|
||||
"【例】返回数组中的非0元素个数。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.count_nonzero(np.eye(4))\n",
|
||||
"print(x) # 4\n",
|
||||
"\n",
|
||||
"x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]])\n",
|
||||
"print(x) # 5\n",
|
||||
"\n",
|
||||
"x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]], axis=0)\n",
|
||||
"print(x) # [1 1 1 1 1]\n",
|
||||
"\n",
|
||||
"x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]], axis=1)\n",
|
||||
"print(x) # [2 3]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"**参考文献**\n",
|
||||
"\n",
|
||||
"- https://blog.csdn.net/u013698770/article/details/54632047\n",
|
||||
"- https://www.cnblogs.com/massquantity/p/8908859.html\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.6.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,246 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 集合操作\n",
|
||||
"\n",
|
||||
"## 构造集合\n",
|
||||
"\n",
|
||||
"- `numpy.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)` Find the unique elements of an array.\n",
|
||||
" - `return_index=True` 表示返回新列表元素在旧列表中的位置。\n",
|
||||
" - `return_inverse=True`表示返回旧列表元素在新列表中的位置。\n",
|
||||
" - `return_counts=True`表示返回新列表元素在旧列表中出现的次数。\n",
|
||||
" \n",
|
||||
" \n",
|
||||
"【例】找出数组中的唯一值并返回已排序的结果。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.unique([1, 1, 3, 2, 3, 3])\n",
|
||||
"print(x) # [1 2 3]\n",
|
||||
"\n",
|
||||
"x = sorted(set([1, 1, 3, 2, 3, 3]))\n",
|
||||
"print(x) # [1, 2, 3]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 1], [2, 3]])\n",
|
||||
"u = np.unique(x)\n",
|
||||
"print(u) # [1 2 3]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])\n",
|
||||
"y = np.unique(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[1 0 0]\n",
|
||||
"# [2 3 4]]\n",
|
||||
"\n",
|
||||
"x = np.array(['a', 'b', 'b', 'c', 'a'])\n",
|
||||
"u, index = np.unique(x, return_index=True)\n",
|
||||
"print(u) # ['a' 'b' 'c']\n",
|
||||
"print(index) # [0 1 3]\n",
|
||||
"print(x[index]) # ['a' 'b' 'c']\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 6, 4, 2, 3, 2])\n",
|
||||
"u, index = np.unique(x, return_inverse=True)\n",
|
||||
"print(u) # [1 2 3 4 6]\n",
|
||||
"print(index) # [0 1 4 3 1 2 1]\n",
|
||||
"print(u[index]) # [1 2 6 4 2 3 2]\n",
|
||||
"\n",
|
||||
"u, count = np.unique(x, return_counts=True)\n",
|
||||
"print(u) # [1 2 3 4 6]\n",
|
||||
"print(count) # [1 3 1 1 1]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"## 布尔运算\n",
|
||||
"\n",
|
||||
"- `numpy.in1d(ar1, ar2, assume_unique=False, invert=False)` Test whether each element of a 1-D array is also present in a second array.\n",
|
||||
"\n",
|
||||
"Returns a boolean array the same length as `ar1` that is True where an element of `ar1` is in `ar2` and False otherwise.\n",
|
||||
"\n",
|
||||
"【例】前面的数组是否包含于后面的数组，返回布尔值。返回的值是针对第一个参数的数组的，所以维数和第一个参数一致，布尔值与数组的元素位置也一一对应。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"test = np.array([0, 1, 2, 5, 0])\n",
|
||||
"states = [0, 2]\n",
|
||||
"mask = np.in1d(test, states)\n",
|
||||
"print(mask) # [ True False True False True]\n",
|
||||
"print(test[mask]) # [0 2 0]\n",
|
||||
"\n",
|
||||
"mask = np.in1d(test, states, invert=True)\n",
|
||||
"print(mask) # [False True False True False]\n",
|
||||
"print(test[mask]) # [1 5]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"### 求两个集合的交集：\n",
|
||||
"\n",
|
||||
"- `numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False)` Find the intersection of two arrays.\n",
|
||||
"\n",
|
||||
"Return the sorted, unique values that are in both of the input arrays.\n",
|
||||
"\n",
|
||||
"【例】求两个数组的唯一化+求交集+排序函数。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"from functools import reduce\n",
|
||||
"\n",
|
||||
"x = np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])\n",
|
||||
"print(x) # [1 3]\n",
|
||||
"\n",
|
||||
"x = np.array([1, 1, 2, 3, 4])\n",
|
||||
"y = np.array([2, 1, 4, 6])\n",
|
||||
"xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)\n",
|
||||
"print(x_ind) # [0 2 4]\n",
|
||||
"print(y_ind) # [1 0 2]\n",
|
||||
"print(xy) # [1 2 4]\n",
|
||||
"print(x[x_ind]) # [1 2 4]\n",
|
||||
"print(y[y_ind]) # [1 2 4]\n",
|
||||
"\n",
|
||||
"x = reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))\n",
|
||||
"print(x) # [3]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### 求两个集合的并集：\n",
|
||||
"\n",
|
||||
"- `numpy.union1d(ar1, ar2)` Find the union of two arrays.\n",
|
||||
"\n",
|
||||
"Return the unique, sorted array of values that are in either of the two input arrays.\n",
|
||||
"\n",
|
||||
"【例】计算两个集合的并集，唯一化并排序。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"from functools import reduce\n",
|
||||
"\n",
|
||||
"x = np.union1d([-1, 0, 1], [-2, 0, 2])\n",
|
||||
"print(x) # [-2 -1 0 1 2]\n",
|
||||
"x = reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))\n",
|
||||
"print(x) # [1 2 3 4 6]\n",
|
||||
"'''\n",
|
||||
"functools.reduce(function, iterable[, initializer])\n",
|
||||
"将两个参数的 function 从左至右积累地应用到 iterable 的条目，以便将该可迭代对象缩减为单一的值。 例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 是计算 ((((1+2)+3)+4)+5) 的值。 左边的参数 x 是积累值而右边的参数 y 则是来自 iterable 的更新值。 如果存在可选项 initializer，它会被放在参与计算的可迭代对象的条目之前，并在可迭代对象为空时作为默认值。 如果没有给出 initializer 并且 iterable 仅包含一个条目，则将返回第一项。\n",
|
||||
"\n",
|
||||
"大致相当于：\n",
|
||||
"def reduce(function, iterable, initializer=None):\n",
|
||||
" it = iter(iterable)\n",
|
||||
" if initializer is None:\n",
|
||||
" value = next(it)\n",
|
||||
" else:\n",
|
||||
" value = initializer\n",
|
||||
" for element in it:\n",
|
||||
" value = function(value, element)\n",
|
||||
" return value\n",
|
||||
"'''\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### 求两个集合的差集：\n",
|
||||
"\n",
|
||||
"- `numpy.setdiff1d(ar1, ar2, assume_unique=False)` Find the set difference of two arrays.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"Return the unique values in `ar1` that are not in `ar2`.\n",
|
||||
"\n",
|
||||
"【例】集合的差，即元素存在于第一个函数不存在于第二个函数中。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.array([1, 2, 3, 2, 4, 1])\n",
|
||||
"b = np.array([3, 4, 5, 6])\n",
|
||||
"x = np.setdiff1d(a, b)\n",
|
||||
"print(x) # [1 2]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### 求两个集合的异或：\n",
|
||||
"\n",
|
||||
"- `setxor1d(ar1, ar2, assume_unique=False)` Find the set exclusive-or of two arrays.\n",
|
||||
"\n",
|
||||
"【例】集合的对称差，即两个集合的交集的补集。简言之，就是两个数组中各自独自拥有的元素的集合。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.array([1, 2, 3, 2, 4, 1])\n",
|
||||
"b = np.array([3, 4, 5, 6])\n",
|
||||
"x = np.setxor1d(a, b)\n",
|
||||
"print(x) # [1 2 5 6]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"**参考文献**\n",
|
||||
"- https://www.jianshu.com/p/3bfe21aa1adb\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.6.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@@ -1,372 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 输入和输出\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## numpy 二进制文件\n",
|
||||
"\n",
|
||||
"`save()`、`savez()`和`load()`函数以 numpy 专用的二进制类型（npy、npz）保存和读取数据，这三个函数会自动处理ndim、dtype、shape等信息，使用它们读写数组非常方便，但是`save()`输出的文件很难与其它语言编写的程序兼容。\n",
|
||||
"\n",
|
||||
"npy格式：以二进制的方式存储文件，在二进制文件第一行以文本形式保存了数据的元信息（ndim，dtype，shape等），可以用二进制工具查看内容。\n",
|
||||
"\n",
|
||||
"npz格式：以压缩打包的方式存储文件，可以用压缩软件解压。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.save(file, arr, allow_pickle=True, fix_imports=True)` Save an array to a binary file in NumPy `.npy` format.\n",
|
||||
"- `numpy.load(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII')` Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"outfile = r'.\\test.npy'\n",
|
||||
"np.random.seed(20200619)\n",
|
||||
"x = np.random.uniform(0, 1, [3, 5])\n",
|
||||
"np.save(outfile, x)\n",
|
||||
"y = np.load(outfile)\n",
|
||||
"print(y)\n",
|
||||
"# [[0.01123594 0.66790705 0.50212171 0.7230908 0.61668256]\n",
|
||||
"# [0.00668332 0.1234096 0.96092409 0.67925305 0.38596837]\n",
|
||||
"# [0.72342998 0.26258324 0.24318845 0.98795012 0.77370715]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.savez(file, *args, **kwds)` Save several arrays into a single file in uncompressed `.npz` format.\n",
|
||||
"\n",
|
||||
"`savez()`第一个参数是文件名，其后的参数都是需要保存的数组，也可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为`arr_0, arr_1, …`。\n",
|
||||
"\n",
|
||||
"`savez()`输出的是一个压缩文件（扩展名为npz），其中每个文件都是一个`save()`保存的npy文件，文件名对应于数组名。`load()`自动识别npz文件，并且返回一个类似于字典的对象，可以通过数组名作为关键字获取数组的内容。\n",
|
||||
"\n",
|
||||
"【例】将多个数组保存到一个文件，可以使用`numpy.savez()`函数。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"outfile = r'.\\test.npz'\n",
|
||||
"x = np.linspace(0, np.pi, 5)\n",
|
||||
"y = np.sin(x)\n",
|
||||
"z = np.cos(x)\n",
|
||||
"np.savez(outfile, x, y, z_d=z)\n",
|
||||
"data = np.load(outfile)\n",
|
||||
"np.set_printoptions(suppress=True)\n",
|
||||
"print(data.files) \n",
|
||||
"# ['z_d', 'arr_0', 'arr_1']\n",
|
||||
"\n",
|
||||
"print(data['arr_0'])\n",
|
||||
"# [0. 0.78539816 1.57079633 2.35619449 3.14159265]\n",
|
||||
"\n",
|
||||
"print(data['arr_1'])\n",
|
||||
"# [0. 0.70710678 1. 0.70710678 0. ]\n",
|
||||
"\n",
|
||||
"print(data['z_d'])\n",
|
||||
"# [ 1. 0.70710678 0. -0.70710678 -1. ]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"用解压软件打开 test.npz 文件，会发现其中有三个文件：`arr_0.npy,arr_1.npy,z_d.npy`，其中分别保存着数组`x,y,z`的内容。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 文本文件\n",
|
||||
"`savetxt()`，`loadtxt()`和`genfromtxt()`函数用来存储和读取文本文件（如TXT，CSV等）。`genfromtxt()`比`loadtxt()`更加强大，可对缺失数据进行处理。\n",
|
||||
"\n",
|
||||
"- `numpy.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\\n', header='', footer='', comments='# ', encoding=None)` Save an array to a text file.\n",
|
||||
" - fname：文件路径\n",
|
||||
" - X：存入文件的数组。\n",
|
||||
" - fmt：写入文件中每个元素的字符串格式，默认'%.18e'（保留18位小数的浮点数形式）。\n",
|
||||
" - delimiter：分割字符串，默认以空格分隔。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.loadtxt(fname, dtype=float, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None)` Load data from a text file. \n",
|
||||
" - fname：文件路径。\n",
|
||||
" - dtype：数据类型，默认为float。\n",
|
||||
" - comments: 字符串或字符串组成的列表，默认为# ， 表示注释字符集开始的标志。\n",
|
||||
" - skiprows：跳过多少行，一般跳过第一行表头。\n",
|
||||
" - usecols：元组（元组内数据为列的数值索引）， 用来指定要读取数据的列（第一列为0）。\n",
|
||||
" - unpack：当加载多列数据时是否需要将数据列进行解耦赋值给不同的变量。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】写入和读出TXT文件。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"outfile = r'.\\test.txt'\n",
|
||||
"x = np.arange(0, 10).reshape(2, -1)\n",
|
||||
"np.savetxt(outfile, x)\n",
|
||||
"y = np.loadtxt(outfile)\n",
|
||||
"print(y)\n",
|
||||
"# [[0. 1. 2. 3. 4.]\n",
|
||||
"# [5. 6. 7. 8. 9.]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"test.txt文件如下：\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"0.000000000000000000e+00 1.000000000000000000e+00 2.000000000000000000e+00 3.000000000000000000e+00 4.000000000000000000e+00\n",
|
||||
"5.000000000000000000e+00 6.000000000000000000e+00 7.000000000000000000e+00 8.000000000000000000e+00 9.000000000000000000e+00\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】写入和读出CSV文件。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"outfile = r'.\\test.csv'\n",
|
||||
"x = np.arange(0, 10, 0.5).reshape(4, -1)\n",
|
||||
"np.savetxt(outfile, x, fmt='%.3f', delimiter=',')\n",
|
||||
"y = np.loadtxt(outfile, delimiter=',')\n",
|
||||
"print(y)\n",
|
||||
"# [[0. 0.5 1. 1.5 2. ]\n",
|
||||
"# [2.5 3. 3.5 4. 4.5]\n",
|
||||
"# [5. 5.5 6. 6.5 7. ]\n",
|
||||
"# [7.5 8. 8.5 9. 9.5]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"test.csv文件如下：\n",
|
||||
"```python\n",
|
||||
"0.000,0.500,1.000,1.500,2.000\n",
|
||||
"2.500,3.000,3.500,4.000,4.500\n",
|
||||
"5.000,5.500,6.000,6.500,7.000\n",
|
||||
"7.500,8.000,8.500,9.000,9.500\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"`genfromtxt()`是面向结构数组和缺失数据处理的。\n",
|
||||
"\n",
|
||||
"- `numpy.genfromtxt(fname, dtype=float, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=''.join(sorted(NameValidator.defaultdeletechars)), replace_space='_', autostrip=False, case_sensitive=True, defaultfmt=\"f%i\", unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None, encoding='bytes')` Load data from a text file, with missing values handled as specified.\n",
|
||||
" - names：设置为True时，程序将把第一行作为列名称。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"data.csv文件如下：\n",
|
||||
"```python\n",
|
||||
"id,value1,value2,value3\n",
|
||||
"1,123,1.4,23\n",
|
||||
"2,110,0.5,18\n",
|
||||
"3,164,2.1,19\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"outfile = r'.\\data.csv'\n",
|
||||
"x = np.loadtxt(outfile, delimiter=',', skiprows=1)\n",
|
||||
"print(x)\n",
|
||||
"# [[ 1. 123. 1.4 23. ]\n",
|
||||
"# [ 2. 110. 0.5 18. ]\n",
|
||||
"# [ 3. 164. 2.1 19. ]]\n",
|
||||
"\n",
|
||||
"x = np.loadtxt(outfile, delimiter=',', skiprows=1, usecols=(1, 2))\n",
|
||||
"print(x)\n",
|
||||
"# [[123. 1.4]\n",
|
||||
"# [110. 0.5]\n",
|
||||
"# [164. 2.1]]\n",
|
||||
"\n",
|
||||
"val1, val2 = np.loadtxt(outfile, delimiter=',', skiprows=1, usecols=(1, 2), unpack=True)\n",
|
||||
"print(val1) # [123. 110. 164.]\n",
|
||||
"print(val2) # [1.4 0.5 2.1]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"outfile = r'.\\data.csv'\n",
|
||||
"x = np.genfromtxt(outfile, delimiter=',', names=True)\n",
|
||||
"print(x)\n",
|
||||
"# [(1., 123., 1.4, 23.) (2., 110., 0.5, 18.) (3., 164., 2.1, 19.)]\n",
|
||||
"\n",
|
||||
"print(type(x)) \n",
|
||||
"# <class 'numpy.ndarray'>\n",
|
||||
"\n",
|
||||
"print(x.dtype)\n",
|
||||
"# [('id', '<f8'), ('value1', '<f8'), ('value2', '<f8'), ('value3', '<f8')]\n",
|
||||
"\n",
|
||||
"print(x['id']) # [1. 2. 3.]\n",
|
||||
"print(x['value1']) # [123. 110. 164.]\n",
|
||||
"print(x['value2']) # [1.4 0.5 2.1]\n",
|
||||
"print(x['value3']) # [23. 18. 19.]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"data1.csv文件\n",
|
||||
"```python\n",
|
||||
"id,value1,value2,value3\n",
|
||||
"1,123,1.4,23\n",
|
||||
"2,110,,18\n",
|
||||
"3,,2.1,19\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"outfile = r'.\\data1.csv'\n",
|
||||
"x = np.genfromtxt(outfile, delimiter=',', names=True)\n",
|
||||
"print(x)\n",
|
||||
"# [(1., 123., 1.4, 23.) (2., 110., nan, 18.) (3., nan, 2.1, 19.)]\n",
|
||||
"\n",
|
||||
"print(type(x)) \n",
|
||||
"# <class 'numpy.ndarray'>\n",
|
||||
"\n",
|
||||
"print(x.dtype)\n",
|
||||
"# [('id', '<f8'), ('value1', '<f8'), ('value2', '<f8'), ('value3', '<f8')]\n",
|
||||
"\n",
|
||||
"print(x['id']) # [1. 2. 3.]\n",
|
||||
"print(x['value1']) # [123. 110. nan]\n",
|
||||
"print(x['value2']) # [1.4 nan 2.1]\n",
|
||||
"print(x['value3']) # [23. 18. 19.]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 文本格式选项\n",
|
||||
"\n",
|
||||
"- `numpy.set_printoptions(precision=None,threshold=None, edgeitems=None,linewidth=None, suppress=None, nanstr=None, infstr=None,formatter=None, sign=None, floatmode=None, **kwarg)` Set printing options.\n",
|
||||
" - `precision`：设置浮点精度，控制输出的小数点个数，默认是8。\n",
|
||||
" - `threshold`：概略显示，超过该值则以“…”的形式来表示，默认是1000。\n",
|
||||
" - `linewidth`：用于确定每行多少字符数后插入换行符，默认为75。\n",
|
||||
" - `suppress`：当`suppress=True`，表示小数不需要以科学计数法的形式输出，默认是False。\n",
|
||||
" - `nanstr`：浮点非数字的字符串表示形式，默认`nan`。\n",
|
||||
" - `infstr`：浮点无穷大的字符串表示形式，默认`inf`。\n",
|
||||
"\n",
|
||||
"These options determine the way floating point numbers, arrays and other NumPy objects are displayed.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.set_printoptions(precision=4)\n",
|
||||
"x = np.array([1.123456789])\n",
|
||||
"print(x) # [1.1235]\n",
|
||||
"\n",
|
||||
"np.set_printoptions(threshold=20)\n",
|
||||
"x = np.arange(50)\n",
|
||||
"print(x) # [ 0 1 2 ... 47 48 49]\n",
|
||||
"\n",
|
||||
"np.set_printoptions(threshold=np.iinfo(np.int).max)\n",
|
||||
"print(x)\n",
|
||||
"# [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
|
||||
"# 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47\n",
|
||||
"# 48 49]\n",
|
||||
"\n",
|
||||
"eps = np.finfo(float).eps\n",
|
||||
"x = np.arange(4.)\n",
|
||||
"x = x ** 2 - (x + eps) ** 2\n",
|
||||
"print(x) \n",
|
||||
"# [-4.9304e-32 -4.4409e-16 0.0000e+00 0.0000e+00]\n",
|
||||
"np.set_printoptions(suppress=True)\n",
|
||||
"print(x) # [-0. -0. 0. 0.]\n",
|
||||
"\n",
|
||||
"x = np.linspace(0, 10, 10)\n",
|
||||
"print(x)\n",
|
||||
"# [ 0. 1.1111 2.2222 3.3333 4.4444 5.5556 6.6667 7.7778 8.8889\n",
|
||||
"# 10. ]\n",
|
||||
"np.set_printoptions(precision=2, suppress=True, threshold=5)\n",
|
||||
"print(x) # [ 0. 1.11 2.22 ... 7.78 8.89 10. ]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.get_printoptions()` Return the current print options.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.get_printoptions()\n",
|
||||
"print(x)\n",
|
||||
"# {\n",
|
||||
"# 'edgeitems': 3, \n",
|
||||
"# 'threshold': 1000, \n",
|
||||
"# 'floatmode': 'maxprec', \n",
|
||||
"# 'precision': 8, \n",
|
||||
"# 'suppress': False, \n",
|
||||
"# 'linewidth': 75, \n",
|
||||
"# 'nanstr': 'nan', \n",
|
||||
"# 'infstr': 'inf', \n",
|
||||
"# 'sign': '-', \n",
|
||||
"# 'formatter': None, \n",
|
||||
"# 'legacy': False\n",
|
||||
"# }\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.6.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
|
Before Width: | Height: | Size: 39 KiB After Width: | Height: | Size: 39 KiB |
Reference in New Issue
Block a user