课程内容提交
This commit is contained in:
MYP
148
IntroductionToNumpy/01 常量.ipynb
Normal file
148
IntroductionToNumpy/01 常量.ipynb
Normal file
@@ -0,0 +1,148 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
250
IntroductionToNumpy/02 数据类型.ipynb
Normal file
250
IntroductionToNumpy/02 数据类型.ipynb
Normal file
@@ -0,0 +1,250 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
356
IntroductionToNumpy/03 时间日期和时间增量.ipynb
Normal file
356
IntroductionToNumpy/03 时间日期和时间增量.ipynb
Normal file
@@ -0,0 +1,356 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
617
IntroductionToNumpy/04 数组的创建.ipynb
Normal file
617
IntroductionToNumpy/04 数组的创建.ipynb
Normal file
@@ -0,0 +1,617 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
731
IntroductionToNumpy/05 索引、切片与迭代.ipynb
Normal file
731
IntroductionToNumpy/05 索引、切片与迭代.ipynb
Normal file
@@ -0,0 +1,731 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
1052
IntroductionToNumpy/06 数组操作.ipynb
Normal file
1052
IntroductionToNumpy/06 数组操作.ipynb
Normal file
File diff suppressed because it is too large
Load Diff
892
IntroductionToNumpy/07 数学函数.ipynb
Normal file
892
IntroductionToNumpy/07 数学函数.ipynb
Normal file
@@ -0,0 +1,892 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
500
IntroductionToNumpy/08 逻辑函数.ipynb
Normal file
500
IntroductionToNumpy/08 逻辑函数.ipynb
Normal file
@@ -0,0 +1,500 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
828
IntroductionToNumpy/09 排序，搜索和计数.ipynb
Normal file
828
IntroductionToNumpy/09 排序，搜索和计数.ipynb
Normal file
@@ -0,0 +1,828 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
246
IntroductionToNumpy/10 集合操作.ipynb
Normal file
246
IntroductionToNumpy/10 集合操作.ipynb
Normal file
@@ -0,0 +1,246 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
661
IntroductionToNumpy/11 随机抽样.ipynb
Normal file
661
IntroductionToNumpy/11 随机抽样.ipynb
Normal file
File diff suppressed because one or more lines are too long
452
IntroductionToNumpy/12 统计相关.ipynb
Normal file
452
IntroductionToNumpy/12 统计相关.ipynb
Normal file
File diff suppressed because one or more lines are too long
656
IntroductionToNumpy/13 线性代数.ipynb
Normal file
656
IntroductionToNumpy/13 线性代数.ipynb
Normal file
File diff suppressed because one or more lines are too long
372
IntroductionToNumpy/14 输入和输出.ipynb
Normal file
372
IntroductionToNumpy/14 输入和输出.ipynb
Normal file
@@ -0,0 +1,372 @@
|
||||
{
|
||||
"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
|
||||
}
|
||||
Reference in New Issue
Block a user