├── .ipynb_checkpoints
├── 01. Numpy和原生Python用于数组计算的性能对比-checkpoint.ipynb
├── 02. Numpy的核心array对象以及创建array的方法-checkpoint.ipynb
├── 03. Numpy对数组按索引查询-checkpoint.ipynb
├── 04. Numpy常用random随机函数汇总-checkpoint.ipynb
├── 05. Numpy的数学统计函数-checkpoint.ipynb
├── 06. Numpy计算数组中满足条件元素个数-checkpoint.ipynb
├── 07. Numpy怎样给数组增加一个维度-checkpoint.ipynb
├── 08. Numpy实现K折交叉验证的数据划分-checkpoint.ipynb
├── 09. Numpy非常有用的数组合并操作-checkpoint.ipynb
├── 10. Numpy怎样对数组排序-checkpoint.ipynb
├── 11. Numpy中数组的乘法-checkpoint.ipynb
├── 12. Numpy中重要的广播概念-checkpoint.ipynb
├── 13. Numpy求解线性方程组-checkpoint.ipynb
├── 14. Numpy实现SVD矩阵分解-checkpoint.ipynb
├── 15. Numpy实现多项式曲线拟合-checkpoint.ipynb
├── 16. Numpy使用Matplotlib实现可视化绘图-checkpoint.ipynb
├── 17. Numpy计算逆矩阵求解线性方程组-checkpoint.ipynb
├── 18. Numpy怎样将数组读写到文件-checkpoint.ipynb
├── 19. Numpy的结构化数组-checkpoint.ipynb
├── 20. Numpy与Pandas数据的相互转换-checkpoint.ipynb
├── 21. Numpy数据输入给Scikit-learn实现模型训练-checkpoint.ipynb
├── Untitled-checkpoint.ipynb
└── Untitled1-checkpoint.ipynb
├── 01. Numpy和原生Python用于数组计算的性能对比.ipynb
├── 02. Numpy的核心array对象以及创建array的方法.ipynb
├── 03. Numpy对数组按索引查询.ipynb
├── 04. Numpy常用random随机函数汇总.ipynb
├── 05. Numpy的数学统计函数.ipynb
├── 06. Numpy计算数组中满足条件元素个数.ipynb
├── 07. Numpy怎样给数组增加一个维度.ipynb
├── 08. Numpy实现K折交叉验证的数据划分.ipynb
├── 09. Numpy非常有用的数组合并操作.ipynb
├── 10. Numpy怎样对数组排序.ipynb
├── 11. Numpy中数组的乘法.ipynb
├── 12. Numpy中重要的广播概念.ipynb
├── 13. Numpy求解线性方程组.ipynb
├── 14. Numpy实现SVD矩阵分解.ipynb
├── 15. Numpy实现多项式曲线拟合.ipynb
├── 16. Numpy使用Matplotlib实现可视化绘图.ipynb
├── 17. Numpy计算逆矩阵求解线性方程组.ipynb
├── 18. Numpy怎样将数组读写到文件.ipynb
├── 19. Numpy的结构化数组.ipynb
├── 20. Numpy与Pandas数据的相互转换.ipynb
├── 21. Numpy数据输入给Scikit-learn实现模型训练.ipynb
├── README.md
├── Untitled.ipynb
├── Untitled1.ipynb
├── arr_a.npy
├── arr_ab.npz
├── arr_ab_compressed.npz
└── other_files
├── numpy-array-inv.jpg
├── numpy-kfold-validation.jpg
├── numpy-kfold-validation.png
└── numpy_random_functions.png
/.ipynb_checkpoints/06. Numpy计算数组中满足条件元素个数-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy计算数组中满足条件元素个数\n",
8 | "\n",
9 | "需求：有一个非常大的数组比如1亿个数字，求出里面数字小于5000的数字数目"
10 | ]
11 | },
12 | {
13 | "cell_type": "markdown",
14 | "metadata": {},
15 | "source": [
16 | "### 1. 使用numpy的random模块生成1亿个数字"
17 | ]
18 | },
19 | {
20 | "cell_type": "code",
21 | "execution_count": 1,
22 | "metadata": {},
23 | "outputs": [],
24 | "source": [
25 | "import numpy as np"
26 | ]
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": 2,
31 | "metadata": {},
32 | "outputs": [],
33 | "source": [
34 | "arr = np.random.randint(1, 10000, size=int(1e8))"
35 | ]
36 | },
37 | {
38 | "cell_type": "code",
39 | "execution_count": 3,
40 | "metadata": {},
41 | "outputs": [
42 | {
43 | "data": {
44 | "text/plain": [
45 | "array([8855, 6014, 4193, 7830, 355, 9469, 1661, 6569, 7647, 5907])"
46 | ]
47 | },
48 | "execution_count": 3,
49 | "metadata": {},
50 | "output_type": "execute_result"
51 | }
52 | ],
53 | "source": [
54 | "arr[:10]"
55 | ]
56 | },
57 | {
58 | "cell_type": "code",
59 | "execution_count": 4,
60 | "metadata": {},
61 | "outputs": [
62 | {
63 | "data": {
64 | "text/plain": [
65 | "100000000"
66 | ]
67 | },
68 | "execution_count": 4,
69 | "metadata": {},
70 | "output_type": "execute_result"
71 | }
72 | ],
73 | "source": [
74 | "arr.size"
75 | ]
76 | },
77 | {
78 | "cell_type": "markdown",
79 | "metadata": {},
80 | "source": [
81 | "### 2. 使用Python原生语法实现"
82 | ]
83 | },
84 | {
85 | "cell_type": "code",
86 | "execution_count": 5,
87 | "metadata": {},
88 | "outputs": [],
89 | "source": [
90 | "pyarr = list(arr)"
91 | ]
92 | },
93 | {
94 | "cell_type": "code",
95 | "execution_count": 6,
96 | "metadata": {},
97 | "outputs": [
98 | {
99 | "data": {
100 | "text/plain": [
101 | "50001207"
102 | ]
103 | },
104 | "execution_count": 6,
105 | "metadata": {},
106 | "output_type": "execute_result"
107 | }
108 | ],
109 | "source": [
110 | "# 计算下结果，用于对比是否准确\n",
111 | "len([x for x in pyarr if x>5000])"
112 | ]
113 | },
114 | {
115 | "cell_type": "code",
116 | "execution_count": 7,
117 | "metadata": {},
118 | "outputs": [
119 | {
120 | "name": "stdout",
121 | "output_type": "stream",
122 | "text": [
123 | "16.6 s ± 252 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
124 | ]
125 | }
126 | ],
127 | "source": [
128 | "# 记一下时间\n",
129 | "%timeit len([x for x in pyarr if x>5000])"
130 | ]
131 | },
132 | {
133 | "cell_type": "markdown",
134 | "metadata": {},
135 | "source": [
136 | "### 3. 使用numpy的向量化操作实现"
137 | ]
138 | },
139 | {
140 | "cell_type": "code",
141 | "execution_count": 8,
142 | "metadata": {},
143 | "outputs": [
144 | {
145 | "data": {
146 | "text/plain": [
147 | "50001207"
148 | ]
149 | },
150 | "execution_count": 8,
151 | "metadata": {},
152 | "output_type": "execute_result"
153 | }
154 | ],
155 | "source": [
156 | "# 计算下结果，用于对比是否准确\n",
157 | "arr[arr>5000].size"
158 | ]
159 | },
160 | {
161 | "cell_type": "code",
162 | "execution_count": 9,
163 | "metadata": {},
164 | "outputs": [
165 | {
166 | "data": {
167 | "text/plain": [
168 | "array([ True, True, False, True, False, True, False, True, True,\n",
169 | " True])"
170 | ]
171 | },
172 | "execution_count": 9,
173 | "metadata": {},
174 | "output_type": "execute_result"
175 | }
176 | ],
177 | "source": [
178 | "(arr>5000)[:10]"
179 | ]
180 | },
181 | {
182 | "cell_type": "code",
183 | "execution_count": 10,
184 | "metadata": {},
185 | "outputs": [
186 | {
187 | "name": "stdout",
188 | "output_type": "stream",
189 | "text": [
190 | "556 ms ± 3.45 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
191 | ]
192 | }
193 | ],
194 | "source": [
195 | "# 记一下时间\n",
196 | "%timeit arr[arr>5000].size"
197 | ]
198 | },
199 | {
200 | "cell_type": "markdown",
201 | "metadata": {},
202 | "source": [
203 | "### 4. 对比下时间"
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": 12,
209 | "metadata": {},
210 | "outputs": [
211 | {
212 | "data": {
213 | "text/plain": [
214 | "29.90990990990991"
215 | ]
216 | },
217 | "execution_count": 12,
218 | "metadata": {},
219 | "output_type": "execute_result"
220 | }
221 | ],
222 | "source": [
223 | "16.6*1000 / 555 "
224 | ]
225 | },
226 | {
227 | "cell_type": "code",
228 | "execution_count": null,
229 | "metadata": {},
230 | "outputs": [],
231 | "source": []
232 | }
233 | ],
234 | "metadata": {
235 | "kernelspec": {
236 | "display_name": "Python 3",
237 | "language": "python",
238 | "name": "python3"
239 | },
240 | "language_info": {
241 | "codemirror_mode": {
242 | "name": "ipython",
243 | "version": 3
244 | },
245 | "file_extension": ".py",
246 | "mimetype": "text/x-python",
247 | "name": "python",
248 | "nbconvert_exporter": "python",
249 | "pygments_lexer": "ipython3",
250 | "version": "3.7.6"
251 | }
252 | },
253 | "nbformat": 4,
254 | "nbformat_minor": 4
255 | }
256 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/07. Numpy怎样给数组增加一个维度-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy怎样给数组增加一个维度"
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "***背景：*** \n",
15 | "很多数据计算都是二维或三维的，对于一维的数据输入为了形状匹配，经常需升维变成二维\n",
16 | "\n",
17 | "***需要：*** \n",
18 | "在不改变数据的情况下，添加数组维度；（注意观察这个例子，维度变了，但数据不变） \n",
19 | "原始数组：一维数组arr=[1,2,3,4]，其shape是(4, )，取值分别为arr[0],arr[1],arr[2],arr[3] \n",
20 | "变形数组：二维数组arr[[1,2,3,4]]，其shape实(1,4), 取值分别为a[0,0],a[0,1],a[0,2],a[0,3]\n",
21 | "\n",
22 | "***实操：*** \n",
23 | "经常需要在纸上手绘数组的形状，来查看不同数组是否形状匹配，是否需要升维降维\n",
24 | "\n",
25 | "***3种方法：*** \n",
26 | "* np.newaxis：关键字，使用索引的语法给数组添加维度\n",
27 | "* np.expand_dims(arr, axis)：方法，和np.newaxis实现一样的功能，给arr在axis位置添加维度\n",
28 | "* np.reshape(a, newshape)：方法，给一个维度设置为1完成升维"
29 | ]
30 | },
31 | {
32 | "cell_type": "code",
33 | "execution_count": 1,
34 | "metadata": {},
35 | "outputs": [],
36 | "source": [
37 | "import numpy as np"
38 | ]
39 | },
40 | {
41 | "cell_type": "code",
42 | "execution_count": 3,
43 | "metadata": {},
44 | "outputs": [
45 | {
46 | "data": {
47 | "text/plain": [
48 | "array([0, 1, 2, 3, 4])"
49 | ]
50 | },
51 | "execution_count": 3,
52 | "metadata": {},
53 | "output_type": "execute_result"
54 | }
55 | ],
56 | "source": [
57 | "arr = np.arange(5)\n",
58 | "arr"
59 | ]
60 | },
61 | {
62 | "cell_type": "code",
63 | "execution_count": 5,
64 | "metadata": {},
65 | "outputs": [
66 | {
67 | "data": {
68 | "text/plain": [
69 | "(5,)"
70 | ]
71 | },
72 | "execution_count": 5,
73 | "metadata": {},
74 | "output_type": "execute_result"
75 | }
76 | ],
77 | "source": [
78 | "# 注意，当前是一维向量\n",
79 | "arr.shape"
80 | ]
81 | },
82 | {
83 | "cell_type": "markdown",
84 | "metadata": {},
85 | "source": [
86 | "### 方法1：np.newaxis关键字"
87 | ]
88 | },
89 | {
90 | "cell_type": "markdown",
91 | "metadata": {},
92 | "source": [
93 | "#### 注意：np.newaxis其实就是None的别名"
94 | ]
95 | },
96 | {
97 | "cell_type": "code",
98 | "execution_count": 6,
99 | "metadata": {},
100 | "outputs": [
101 | {
102 | "data": {
103 | "text/plain": [
104 | "True"
105 | ]
106 | },
107 | "execution_count": 6,
108 | "metadata": {},
109 | "output_type": "execute_result"
110 | }
111 | ],
112 | "source": [
113 | "np.newaxis is None"
114 | ]
115 | },
116 | {
117 | "cell_type": "code",
118 | "execution_count": 7,
119 | "metadata": {},
120 | "outputs": [
121 | {
122 | "data": {
123 | "text/plain": [
124 | "True"
125 | ]
126 | },
127 | "execution_count": 7,
128 | "metadata": {},
129 | "output_type": "execute_result"
130 | }
131 | ],
132 | "source": [
133 | "np.newaxis == None"
134 | ]
135 | },
136 | {
137 | "cell_type": "markdown",
138 | "metadata": {},
139 | "source": [
140 | "即以下所有的np.newaxis的位置，都可以用None替代"
141 | ]
142 | },
143 | {
144 | "cell_type": "markdown",
145 | "metadata": {},
146 | "source": [
147 | "#### 给一维向量添加一个行维度"
148 | ]
149 | },
150 | {
151 | "cell_type": "code",
152 | "execution_count": 8,
153 | "metadata": {},
154 | "outputs": [
155 | {
156 | "data": {
157 | "text/plain": [
158 | "array([[0, 1, 2, 3, 4]])"
159 | ]
160 | },
161 | "execution_count": 8,
162 | "metadata": {},
163 | "output_type": "execute_result"
164 | }
165 | ],
166 | "source": [
167 | "arr[np.newaxis, :]"
168 | ]
169 | },
170 | {
171 | "cell_type": "code",
172 | "execution_count": 9,
173 | "metadata": {
174 | "scrolled": true
175 | },
176 | "outputs": [
177 | {
178 | "data": {
179 | "text/plain": [
180 | "(1, 5)"
181 | ]
182 | },
183 | "execution_count": 9,
184 | "metadata": {},
185 | "output_type": "execute_result"
186 | }
187 | ],
188 | "source": [
189 | "arr[np.newaxis, :].shape"
190 | ]
191 | },
192 | {
193 | "cell_type": "markdown",
194 | "metadata": {},
195 | "source": [
196 | "数据现在是一行*五列，数据本身没有增减，只是多了一级括号"
197 | ]
198 | },
199 | {
200 | "cell_type": "markdown",
201 | "metadata": {},
202 | "source": [
203 | "#### 给一维向量添加一个列维度"
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": 10,
209 | "metadata": {},
210 | "outputs": [
211 | {
212 | "data": {
213 | "text/plain": [
214 | "array([[0],\n",
215 | " [1],\n",
216 | " [2],\n",
217 | " [3],\n",
218 | " [4]])"
219 | ]
220 | },
221 | "execution_count": 10,
222 | "metadata": {},
223 | "output_type": "execute_result"
224 | }
225 | ],
226 | "source": [
227 | "arr[:, np.newaxis]"
228 | ]
229 | },
230 | {
231 | "cell_type": "code",
232 | "execution_count": 11,
233 | "metadata": {},
234 | "outputs": [
235 | {
236 | "data": {
237 | "text/plain": [
238 | "(5, 1)"
239 | ]
240 | },
241 | "execution_count": 11,
242 | "metadata": {},
243 | "output_type": "execute_result"
244 | }
245 | ],
246 | "source": [
247 | "arr[:, np.newaxis].shape"
248 | ]
249 | },
250 | {
251 | "cell_type": "markdown",
252 | "metadata": {},
253 | "source": [
254 | "数据现在是五行*一列"
255 | ]
256 | },
257 | {
258 | "cell_type": "markdown",
259 | "metadata": {},
260 | "source": [
261 | "### 方法2：np.expand_dims方法"
262 | ]
263 | },
264 | {
265 | "cell_type": "markdown",
266 | "metadata": {},
267 | "source": [
268 | "np.expand_dims方法实现的效果，和np.newaxis关键字是一模一样的"
269 | ]
270 | },
271 | {
272 | "cell_type": "code",
273 | "execution_count": 13,
274 | "metadata": {},
275 | "outputs": [
276 | {
277 | "data": {
278 | "text/plain": [
279 | "array([0, 1, 2, 3, 4])"
280 | ]
281 | },
282 | "execution_count": 13,
283 | "metadata": {},
284 | "output_type": "execute_result"
285 | }
286 | ],
287 | "source": [
288 | "arr"
289 | ]
290 | },
291 | {
292 | "cell_type": "markdown",
293 | "metadata": {},
294 | "source": [
295 | "#### 给一维数组添加一个行维度"
296 | ]
297 | },
298 | {
299 | "cell_type": "markdown",
300 | "metadata": {},
301 | "source": [
302 | "相当于arr[np.newaxis, arr]"
303 | ]
304 | },
305 | {
306 | "cell_type": "code",
307 | "execution_count": 14,
308 | "metadata": {},
309 | "outputs": [
310 | {
311 | "data": {
312 | "text/plain": [
313 | "array([[0, 1, 2, 3, 4]])"
314 | ]
315 | },
316 | "execution_count": 14,
317 | "metadata": {},
318 | "output_type": "execute_result"
319 | }
320 | ],
321 | "source": [
322 | "np.expand_dims(arr, axis=0)"
323 | ]
324 | },
325 | {
326 | "cell_type": "code",
327 | "execution_count": 15,
328 | "metadata": {},
329 | "outputs": [
330 | {
331 | "data": {
332 | "text/plain": [
333 | "(1, 5)"
334 | ]
335 | },
336 | "execution_count": 15,
337 | "metadata": {},
338 | "output_type": "execute_result"
339 | }
340 | ],
341 | "source": [
342 | "np.expand_dims(arr, axis=0).shape"
343 | ]
344 | },
345 | {
346 | "cell_type": "markdown",
347 | "metadata": {},
348 | "source": [
349 | "#### 给一维数组添加一个列维度"
350 | ]
351 | },
352 | {
353 | "cell_type": "markdown",
354 | "metadata": {},
355 | "source": [
356 | "相当于arr[arr, np.newaxis]"
357 | ]
358 | },
359 | {
360 | "cell_type": "code",
361 | "execution_count": 16,
362 | "metadata": {},
363 | "outputs": [
364 | {
365 | "data": {
366 | "text/plain": [
367 | "array([[0],\n",
368 | " [1],\n",
369 | " [2],\n",
370 | " [3],\n",
371 | " [4]])"
372 | ]
373 | },
374 | "execution_count": 16,
375 | "metadata": {},
376 | "output_type": "execute_result"
377 | }
378 | ],
379 | "source": [
380 | "np.expand_dims(arr, axis=1)"
381 | ]
382 | },
383 | {
384 | "cell_type": "code",
385 | "execution_count": 17,
386 | "metadata": {},
387 | "outputs": [
388 | {
389 | "data": {
390 | "text/plain": [
391 | "(5, 1)"
392 | ]
393 | },
394 | "execution_count": 17,
395 | "metadata": {},
396 | "output_type": "execute_result"
397 | }
398 | ],
399 | "source": [
400 | "np.expand_dims(arr, axis=1).shape"
401 | ]
402 | },
403 | {
404 | "cell_type": "markdown",
405 | "metadata": {},
406 | "source": [
407 | "### 方法3：np.reshape方法"
408 | ]
409 | },
410 | {
411 | "cell_type": "markdown",
412 | "metadata": {},
413 | "source": [
414 | "#### 给一维数组添加一个行维度"
415 | ]
416 | },
417 | {
418 | "cell_type": "code",
419 | "execution_count": 23,
420 | "metadata": {},
421 | "outputs": [
422 | {
423 | "data": {
424 | "text/plain": [
425 | "array([0, 1, 2, 3, 4])"
426 | ]
427 | },
428 | "execution_count": 23,
429 | "metadata": {},
430 | "output_type": "execute_result"
431 | }
432 | ],
433 | "source": [
434 | "arr"
435 | ]
436 | },
437 | {
438 | "cell_type": "code",
439 | "execution_count": 32,
440 | "metadata": {},
441 | "outputs": [
442 | {
443 | "data": {
444 | "text/plain": [
445 | "array([[0, 1, 2, 3, 4]])"
446 | ]
447 | },
448 | "execution_count": 32,
449 | "metadata": {},
450 | "output_type": "execute_result"
451 | }
452 | ],
453 | "source": [
454 | "np.reshape(arr, (1, 5))"
455 | ]
456 | },
457 | {
458 | "cell_type": "code",
459 | "execution_count": 33,
460 | "metadata": {},
461 | "outputs": [
462 | {
463 | "data": {
464 | "text/plain": [
465 | "array([[0, 1, 2, 3, 4]])"
466 | ]
467 | },
468 | "execution_count": 33,
469 | "metadata": {},
470 | "output_type": "execute_result"
471 | }
472 | ],
473 | "source": [
474 | "np.reshape(arr, (1, -1))"
475 | ]
476 | },
477 | {
478 | "cell_type": "code",
479 | "execution_count": 34,
480 | "metadata": {},
481 | "outputs": [
482 | {
483 | "data": {
484 | "text/plain": [
485 | "(1, 5)"
486 | ]
487 | },
488 | "execution_count": 34,
489 | "metadata": {},
490 | "output_type": "execute_result"
491 | }
492 | ],
493 | "source": [
494 | "np.reshape(arr, (1, -1)).shape"
495 | ]
496 | },
497 | {
498 | "cell_type": "markdown",
499 | "metadata": {},
500 | "source": [
501 | "#### 给一维数组添加一个列维度"
502 | ]
503 | },
504 | {
505 | "cell_type": "code",
506 | "execution_count": 35,
507 | "metadata": {},
508 | "outputs": [
509 | {
510 | "data": {
511 | "text/plain": [
512 | "array([[0],\n",
513 | " [1],\n",
514 | " [2],\n",
515 | " [3],\n",
516 | " [4]])"
517 | ]
518 | },
519 | "execution_count": 35,
520 | "metadata": {},
521 | "output_type": "execute_result"
522 | }
523 | ],
524 | "source": [
525 | "np.reshape(arr, (-1, 1))"
526 | ]
527 | },
528 | {
529 | "cell_type": "code",
530 | "execution_count": 36,
531 | "metadata": {},
532 | "outputs": [
533 | {
534 | "data": {
535 | "text/plain": [
536 | "(5, 1)"
537 | ]
538 | },
539 | "execution_count": 36,
540 | "metadata": {},
541 | "output_type": "execute_result"
542 | }
543 | ],
544 | "source": [
545 | "np.reshape(arr, (-1, 1)).shape"
546 | ]
547 | }
548 | ],
549 | "metadata": {
550 | "kernelspec": {
551 | "display_name": "Python 3",
552 | "language": "python",
553 | "name": "python3"
554 | },
555 | "language_info": {
556 | "codemirror_mode": {
557 | "name": "ipython",
558 | "version": 3
559 | },
560 | "file_extension": ".py",
561 | "mimetype": "text/x-python",
562 | "name": "python",
563 | "nbconvert_exporter": "python",
564 | "pygments_lexer": "ipython3",
565 | "version": "3.7.6"
566 | }
567 | },
568 | "nbformat": 4,
569 | "nbformat_minor": 4
570 | }
571 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/08. Numpy实现K折交叉验证的数据划分-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy实现K折交叉验证的数据划分"
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "本实例使用Numpy的数组切片语法，实现了K折交叉验证的数据划分"
15 | ]
16 | },
17 | {
18 | "cell_type": "markdown",
19 | "metadata": {},
20 | "source": [
21 | "### 背景：K折交叉验证\n",
22 | "\n",
23 | "***为什么需要这个？*** \n",
24 | "在机器学习中，因为如下原因，使用K折交叉验证能更好评估模型效果：\n",
25 | "1. 样本量不充足，划分了训练集和测试集后，训练数据更少；\n",
26 | "2. 训练集和测试集的不同划分，可能会导致不同的模型性能结果；\n",
27 | "\n",
28 | "\n",
29 | "***K折验证是什么*** \n",
30 | "K折验证（K-fold validtion）将数据划分为大小相同的K个分区。 \n",
31 | "对每个分区i，在剩余的K-1个分区上训练模型，然后在分区i上评估模型。 \n",
32 | "最终分数等于K个分数的平均值，使用平均值来消除训练集和测试集的划分影响；\n",
33 | "\n",
34 | "![](\"./other_files/numpy-kfold-validation.png\")
"
35 | ]
36 | },
37 | {
38 | "cell_type": "markdown",
39 | "metadata": {},
40 | "source": [
41 | "### 1. 模拟构造样本集合"
42 | ]
43 | },
44 | {
45 | "cell_type": "code",
46 | "execution_count": 1,
47 | "metadata": {},
48 | "outputs": [],
49 | "source": [
50 | "import numpy as np"
51 | ]
52 | },
53 | {
54 | "cell_type": "code",
55 | "execution_count": 2,
56 | "metadata": {},
57 | "outputs": [
58 | {
59 | "data": {
60 | "text/plain": [
61 | "array([[ 0, 1, 2, 3],\n",
62 | " [ 4, 5, 6, 7],\n",
63 | " [ 8, 9, 10, 11],\n",
64 | " [12, 13, 14, 15],\n",
65 | " [16, 17, 18, 19],\n",
66 | " [20, 21, 22, 23],\n",
67 | " [24, 25, 26, 27],\n",
68 | " [28, 29, 30, 31],\n",
69 | " [32, 33, 34, 35]])"
70 | ]
71 | },
72 | "execution_count": 2,
73 | "metadata": {},
74 | "output_type": "execute_result"
75 | }
76 | ],
77 | "source": [
78 | "data = np.arange(36).reshape(9,4)\n",
79 | "data"
80 | ]
81 | },
82 | {
83 | "cell_type": "markdown",
84 | "metadata": {},
85 | "source": [
86 | "用样本的角度解释下data数组：\n",
87 | "* 这是一个二维矩阵，行代表每个样本，列代表每个特征\n",
88 | "* 这里有9个样本，每个样本有4个特征\n",
89 | "\n",
90 | "这是scikit-learn模型训练输入的标准格式"
91 | ]
92 | },
93 | {
94 | "cell_type": "markdown",
95 | "metadata": {},
96 | "source": [
97 | "### 2. 使用Numpy实现K次划分"
98 | ]
99 | },
100 | {
101 | "cell_type": "code",
102 | "execution_count": 3,
103 | "metadata": {},
104 | "outputs": [],
105 | "source": [
106 | "# 我们想进行4折交叉验证\n",
107 | "k = 4"
108 | ]
109 | },
110 | {
111 | "cell_type": "code",
112 | "execution_count": 4,
113 | "metadata": {},
114 | "outputs": [
115 | {
116 | "data": {
117 | "text/plain": [
118 | "2"
119 | ]
120 | },
121 | "execution_count": 4,
122 | "metadata": {},
123 | "output_type": "execute_result"
124 | }
125 | ],
126 | "source": [
127 | "# 算出来每个fold的样本个数\n",
128 | "k_samples_count = data.shape[0]//k\n",
129 | "k_samples_count"
130 | ]
131 | },
132 | {
133 | "cell_type": "code",
134 | "execution_count": 5,
135 | "metadata": {
136 | "scrolled": false
137 | },
138 | "outputs": [
139 | {
140 | "name": "stdout",
141 | "output_type": "stream",
142 | "text": [
143 | "\n",
144 | "#####第0折#####\n",
145 | "验证集：\n",
146 | " [[0 1 2 3]\n",
147 | " [4 5 6 7]]\n",
148 | "训练集：\n",
149 | " [[ 8 9 10 11]\n",
150 | " [12 13 14 15]\n",
151 | " [16 17 18 19]\n",
152 | " [20 21 22 23]\n",
153 | " [24 25 26 27]\n",
154 | " [28 29 30 31]\n",
155 | " [32 33 34 35]]\n",
156 | "\n",
157 | "#####第1折#####\n",
158 | "验证集：\n",
159 | " [[ 8 9 10 11]\n",
160 | " [12 13 14 15]]\n",
161 | "训练集：\n",
162 | " [[ 0 1 2 3]\n",
163 | " [ 4 5 6 7]\n",
164 | " [16 17 18 19]\n",
165 | " [20 21 22 23]\n",
166 | " [24 25 26 27]\n",
167 | " [28 29 30 31]\n",
168 | " [32 33 34 35]]\n",
169 | "\n",
170 | "#####第2折#####\n",
171 | "验证集：\n",
172 | " [[16 17 18 19]\n",
173 | " [20 21 22 23]]\n",
174 | "训练集：\n",
175 | " [[ 0 1 2 3]\n",
176 | " [ 4 5 6 7]\n",
177 | " [ 8 9 10 11]\n",
178 | " [12 13 14 15]\n",
179 | " [24 25 26 27]\n",
180 | " [28 29 30 31]\n",
181 | " [32 33 34 35]]\n",
182 | "\n",
183 | "#####第3折#####\n",
184 | "验证集：\n",
185 | " [[24 25 26 27]\n",
186 | " [28 29 30 31]]\n",
187 | "训练集：\n",
188 | " [[ 0 1 2 3]\n",
189 | " [ 4 5 6 7]\n",
190 | " [ 8 9 10 11]\n",
191 | " [12 13 14 15]\n",
192 | " [16 17 18 19]\n",
193 | " [20 21 22 23]\n",
194 | " [32 33 34 35]]\n"
195 | ]
196 | }
197 | ],
198 | "source": [
199 | "for fold in range(k):\n",
200 | " validation_begin = k_samples_count*fold\n",
201 | " validation_end = k_samples_count*(fold+1)\n",
202 | " \n",
203 | " validation_data = data[validation_begin:validation_end]\n",
204 | " \n",
205 | " # np.vstack，沿着垂直的方向堆叠数组\n",
206 | " train_data = np.vstack([\n",
207 | " data[:validation_begin], \n",
208 | " data[validation_end:]\n",
209 | " ])\n",
210 | " \n",
211 | " print()\n",
212 | " print(f\"#####第{fold}折#####\")\n",
213 | " print(\"验证集：\\n\", validation_data)\n",
214 | " print(\"训练集：\\n\", train_data)"
215 | ]
216 | },
217 | {
218 | "cell_type": "markdown",
219 | "metadata": {},
220 | "source": [
221 | "如果使用scikit-learn，已经有封装好的实现： \n",
222 | "from sklearn.model_selection import cross_val_score"
223 | ]
224 | }
225 | ],
226 | "metadata": {
227 | "kernelspec": {
228 | "display_name": "Python 3",
229 | "language": "python",
230 | "name": "python3"
231 | },
232 | "language_info": {
233 | "codemirror_mode": {
234 | "name": "ipython",
235 | "version": 3
236 | },
237 | "file_extension": ".py",
238 | "mimetype": "text/x-python",
239 | "name": "python",
240 | "nbconvert_exporter": "python",
241 | "pygments_lexer": "ipython3",
242 | "version": "3.7.6"
243 | }
244 | },
245 | "nbformat": 4,
246 | "nbformat_minor": 4
247 | }
248 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/09. Numpy非常有用的数组合并操作-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy非常重要有用的数组合并操作"
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "背景：在给机器学习准备数据的过程中，经常需要进行不同来源的数据合并的操作。\n",
15 | "\n",
16 | "两类场景：\n",
17 | "1. 给已有的数据添加多行，比如增添一些样本数据进去；\n",
18 | "2. 给已有的数据添加多列，比如增添一些特征进去；\n",
19 | "\n",
20 | "以下操作均可以实现数组合并：\n",
21 | "* np.concatenate(array_list, axis=0/1）：沿着指定axis进行数组的合并\n",
22 | "* np.vstack或者np.row_stack(array_list)：垂直vertically、按行row wise进行数据合并\n",
23 | "* np.hstack或者np.column_stack(array_list)：水平horizontally、按列column wise进行数据合并"
24 | ]
25 | },
26 | {
27 | "cell_type": "code",
28 | "execution_count": 1,
29 | "metadata": {},
30 | "outputs": [],
31 | "source": [
32 | "import numpy as np"
33 | ]
34 | },
35 | {
36 | "cell_type": "markdown",
37 | "metadata": {},
38 | "source": [
39 | "### 1. 怎样给数据添加新的多行"
40 | ]
41 | },
42 | {
43 | "cell_type": "code",
44 | "execution_count": 2,
45 | "metadata": {},
46 | "outputs": [],
47 | "source": [
48 | "a = np.arange(6).reshape(2,3)\n",
49 | "b = np.random.randint(10,20,size=(4,3))"
50 | ]
51 | },
52 | {
53 | "cell_type": "code",
54 | "execution_count": 3,
55 | "metadata": {},
56 | "outputs": [
57 | {
58 | "data": {
59 | "text/plain": [
60 | "array([[0, 1, 2],\n",
61 | " [3, 4, 5]])"
62 | ]
63 | },
64 | "execution_count": 3,
65 | "metadata": {},
66 | "output_type": "execute_result"
67 | }
68 | ],
69 | "source": [
70 | "a"
71 | ]
72 | },
73 | {
74 | "cell_type": "code",
75 | "execution_count": 4,
76 | "metadata": {},
77 | "outputs": [
78 | {
79 | "data": {
80 | "text/plain": [
81 | "array([[12, 11, 14],\n",
82 | " [18, 15, 10],\n",
83 | " [11, 15, 15],\n",
84 | " [19, 16, 10]])"
85 | ]
86 | },
87 | "execution_count": 4,
88 | "metadata": {},
89 | "output_type": "execute_result"
90 | }
91 | ],
92 | "source": [
93 | "b"
94 | ]
95 | },
96 | {
97 | "cell_type": "code",
98 | "execution_count": 5,
99 | "metadata": {},
100 | "outputs": [
101 | {
102 | "data": {
103 | "text/plain": [
104 | "array([[ 0, 1, 2],\n",
105 | " [ 3, 4, 5],\n",
106 | " [12, 11, 14],\n",
107 | " [18, 15, 10],\n",
108 | " [11, 15, 15],\n",
109 | " [19, 16, 10]])"
110 | ]
111 | },
112 | "execution_count": 5,
113 | "metadata": {},
114 | "output_type": "execute_result"
115 | }
116 | ],
117 | "source": [
118 | "# 方法1：\n",
119 | "np.concatenate([a,b])"
120 | ]
121 | },
122 | {
123 | "cell_type": "code",
124 | "execution_count": 6,
125 | "metadata": {},
126 | "outputs": [
127 | {
128 | "data": {
129 | "text/plain": [
130 | "array([[ 0, 1, 2],\n",
131 | " [ 3, 4, 5],\n",
132 | " [12, 11, 14],\n",
133 | " [18, 15, 10],\n",
134 | " [11, 15, 15],\n",
135 | " [19, 16, 10]])"
136 | ]
137 | },
138 | "execution_count": 6,
139 | "metadata": {},
140 | "output_type": "execute_result"
141 | }
142 | ],
143 | "source": [
144 | "# 方法2\n",
145 | "np.vstack([a,b])"
146 | ]
147 | },
148 | {
149 | "cell_type": "code",
150 | "execution_count": 7,
151 | "metadata": {},
152 | "outputs": [
153 | {
154 | "data": {
155 | "text/plain": [
156 | "array([[ 0, 1, 2],\n",
157 | " [ 3, 4, 5],\n",
158 | " [12, 11, 14],\n",
159 | " [18, 15, 10],\n",
160 | " [11, 15, 15],\n",
161 | " [19, 16, 10]])"
162 | ]
163 | },
164 | "execution_count": 7,
165 | "metadata": {},
166 | "output_type": "execute_result"
167 | }
168 | ],
169 | "source": [
170 | "# 方法3\n",
171 | "np.row_stack([a, b])"
172 | ]
173 | },
174 | {
175 | "cell_type": "markdown",
176 | "metadata": {},
177 | "source": [
178 | "### 2. 怎样给数据添加新的多列"
179 | ]
180 | },
181 | {
182 | "cell_type": "code",
183 | "execution_count": 8,
184 | "metadata": {},
185 | "outputs": [],
186 | "source": [
187 | "a = np.arange(12).reshape(3,4)\n",
188 | "b = np.random.randint(10,20,size=(3,2))"
189 | ]
190 | },
191 | {
192 | "cell_type": "code",
193 | "execution_count": 9,
194 | "metadata": {},
195 | "outputs": [
196 | {
197 | "data": {
198 | "text/plain": [
199 | "array([[ 0, 1, 2, 3],\n",
200 | " [ 4, 5, 6, 7],\n",
201 | " [ 8, 9, 10, 11]])"
202 | ]
203 | },
204 | "execution_count": 9,
205 | "metadata": {},
206 | "output_type": "execute_result"
207 | }
208 | ],
209 | "source": [
210 | "a"
211 | ]
212 | },
213 | {
214 | "cell_type": "code",
215 | "execution_count": 10,
216 | "metadata": {},
217 | "outputs": [
218 | {
219 | "data": {
220 | "text/plain": [
221 | "array([[16, 10],\n",
222 | " [12, 17],\n",
223 | " [12, 10]])"
224 | ]
225 | },
226 | "execution_count": 10,
227 | "metadata": {},
228 | "output_type": "execute_result"
229 | }
230 | ],
231 | "source": [
232 | "b"
233 | ]
234 | },
235 | {
236 | "cell_type": "code",
237 | "execution_count": 11,
238 | "metadata": {},
239 | "outputs": [
240 | {
241 | "data": {
242 | "text/plain": [
243 | "array([[ 0, 1, 2, 3, 16, 10],\n",
244 | " [ 4, 5, 6, 7, 12, 17],\n",
245 | " [ 8, 9, 10, 11, 12, 10]])"
246 | ]
247 | },
248 | "execution_count": 11,
249 | "metadata": {},
250 | "output_type": "execute_result"
251 | }
252 | ],
253 | "source": [
254 | "# 方法1\n",
255 | "np.concatenate([a,b], axis=1)"
256 | ]
257 | },
258 | {
259 | "cell_type": "code",
260 | "execution_count": 12,
261 | "metadata": {},
262 | "outputs": [
263 | {
264 | "data": {
265 | "text/plain": [
266 | "array([[ 0, 1, 2, 3, 16, 10],\n",
267 | " [ 4, 5, 6, 7, 12, 17],\n",
268 | " [ 8, 9, 10, 11, 12, 10]])"
269 | ]
270 | },
271 | "execution_count": 12,
272 | "metadata": {},
273 | "output_type": "execute_result"
274 | }
275 | ],
276 | "source": [
277 | "# 方法2\n",
278 | "np.hstack([a,b])"
279 | ]
280 | },
281 | {
282 | "cell_type": "code",
283 | "execution_count": 13,
284 | "metadata": {},
285 | "outputs": [
286 | {
287 | "data": {
288 | "text/plain": [
289 | "array([[ 0, 1, 2, 3, 16, 10],\n",
290 | " [ 4, 5, 6, 7, 12, 17],\n",
291 | " [ 8, 9, 10, 11, 12, 10]])"
292 | ]
293 | },
294 | "execution_count": 13,
295 | "metadata": {},
296 | "output_type": "execute_result"
297 | }
298 | ],
299 | "source": [
300 | "# 方法3\n",
301 | "np.column_stack([a,b])"
302 | ]
303 | }
304 | ],
305 | "metadata": {
306 | "kernelspec": {
307 | "display_name": "Python 3",
308 | "language": "python",
309 | "name": "python3"
310 | },
311 | "language_info": {
312 | "codemirror_mode": {
313 | "name": "ipython",
314 | "version": 3
315 | },
316 | "file_extension": ".py",
317 | "mimetype": "text/x-python",
318 | "name": "python",
319 | "nbconvert_exporter": "python",
320 | "pygments_lexer": "ipython3",
321 | "version": "3.7.6"
322 | }
323 | },
324 | "nbformat": 4,
325 | "nbformat_minor": 4
326 | }
327 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/10. Numpy怎样对数组排序-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy怎样对数组排序\n",
8 | "\n",
9 | "Numpy给数组排序的三个方法： \n",
10 | "* numpy.sort：返回排序后数组的拷贝\n",
11 | "* array.sort：原地排序数组而不是返回拷贝\n",
12 | "* numpy.argsort：间接排序，返回的是排序后的数字索引\n",
13 | "\n",
14 | "3个方法都支持一个参数kind，可以是以下一个值：\n",
15 | "* quicksort：快速排序，平均O(nlogn)，不稳定情况\n",
16 | "* mergesort：归并排序，平均O(nlogn)，稳定排序\n",
17 | "* heapsort：堆排序，平均O(nlogn)，不稳定排序\n",
18 | "* stable：稳定排序\n",
19 | "\n",
20 | "kind默认值是quicksort，快速排序平均情况是最快，保持默认即可"
21 | ]
22 | },
23 | {
24 | "cell_type": "code",
25 | "execution_count": 1,
26 | "metadata": {},
27 | "outputs": [],
28 | "source": [
29 | "import numpy as np"
30 | ]
31 | },
32 | {
33 | "cell_type": "markdown",
34 | "metadata": {},
35 | "source": [
36 | "### 1. np.sort返回排序后的数组"
37 | ]
38 | },
39 | {
40 | "cell_type": "code",
41 | "execution_count": 2,
42 | "metadata": {},
43 | "outputs": [],
44 | "source": [
45 | "arr = np.array([3, 2, 4, 5, 1, 9, 7, 8, 6])"
46 | ]
47 | },
48 | {
49 | "cell_type": "code",
50 | "execution_count": 3,
51 | "metadata": {},
52 | "outputs": [
53 | {
54 | "data": {
55 | "text/plain": [
56 | "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
57 | ]
58 | },
59 | "execution_count": 3,
60 | "metadata": {},
61 | "output_type": "execute_result"
62 | }
63 | ],
64 | "source": [
65 | "# 返回拷贝后的数组\n",
66 | "np.sort(arr)"
67 | ]
68 | },
69 | {
70 | "cell_type": "code",
71 | "execution_count": 4,
72 | "metadata": {},
73 | "outputs": [
74 | {
75 | "data": {
76 | "text/plain": [
77 | "array([3, 2, 4, 5, 1, 9, 7, 8, 6])"
78 | ]
79 | },
80 | "execution_count": 4,
81 | "metadata": {},
82 | "output_type": "execute_result"
83 | }
84 | ],
85 | "source": [
86 | "arr"
87 | ]
88 | },
89 | {
90 | "cell_type": "markdown",
91 | "metadata": {},
92 | "source": [
93 | "### 2. array.sort进行原地排序"
94 | ]
95 | },
96 | {
97 | "cell_type": "code",
98 | "execution_count": 5,
99 | "metadata": {},
100 | "outputs": [],
101 | "source": [
102 | "arr2 = arr.copy()"
103 | ]
104 | },
105 | {
106 | "cell_type": "code",
107 | "execution_count": 6,
108 | "metadata": {},
109 | "outputs": [
110 | {
111 | "data": {
112 | "text/plain": [
113 | "array([3, 2, 4, 5, 1, 9, 7, 8, 6])"
114 | ]
115 | },
116 | "execution_count": 6,
117 | "metadata": {},
118 | "output_type": "execute_result"
119 | }
120 | ],
121 | "source": [
122 | "arr2"
123 | ]
124 | },
125 | {
126 | "cell_type": "code",
127 | "execution_count": 7,
128 | "metadata": {},
129 | "outputs": [],
130 | "source": [
131 | "arr2.sort()"
132 | ]
133 | },
134 | {
135 | "cell_type": "code",
136 | "execution_count": 8,
137 | "metadata": {},
138 | "outputs": [
139 | {
140 | "data": {
141 | "text/plain": [
142 | "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
143 | ]
144 | },
145 | "execution_count": 8,
146 | "metadata": {},
147 | "output_type": "execute_result"
148 | }
149 | ],
150 | "source": [
151 | "arr2"
152 | ]
153 | },
154 | {
155 | "cell_type": "markdown",
156 | "metadata": {},
157 | "source": [
158 | "### 3. np.argsort 返回的是有序数字的索引"
159 | ]
160 | },
161 | {
162 | "cell_type": "code",
163 | "execution_count": 9,
164 | "metadata": {},
165 | "outputs": [
166 | {
167 | "data": {
168 | "text/plain": [
169 | "array([3, 2, 4, 5, 1, 9, 7, 8, 6])"
170 | ]
171 | },
172 | "execution_count": 9,
173 | "metadata": {},
174 | "output_type": "execute_result"
175 | }
176 | ],
177 | "source": [
178 | "arr"
179 | ]
180 | },
181 | {
182 | "cell_type": "code",
183 | "execution_count": 10,
184 | "metadata": {},
185 | "outputs": [
186 | {
187 | "data": {
188 | "text/plain": [
189 | "array([4, 1, 0, 2, 3, 8, 6, 7, 5], dtype=int64)"
190 | ]
191 | },
192 | "execution_count": 10,
193 | "metadata": {},
194 | "output_type": "execute_result"
195 | }
196 | ],
197 | "source": [
198 | "# 获得排序元素对应的索引数字列表\n",
199 | "indices = np.argsort(arr)\n",
200 | "indices"
201 | ]
202 | },
203 | {
204 | "cell_type": "code",
205 | "execution_count": 11,
206 | "metadata": {
207 | "scrolled": true
208 | },
209 | "outputs": [
210 | {
211 | "data": {
212 | "text/plain": [
213 | "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
214 | ]
215 | },
216 | "execution_count": 11,
217 | "metadata": {},
218 | "output_type": "execute_result"
219 | }
220 | ],
221 | "source": [
222 | "# 可以直接获取对应的数据列表\n",
223 | "arr[indices]"
224 | ]
225 | },
226 | {
227 | "cell_type": "markdown",
228 | "metadata": {},
229 | "source": [
230 | "### 4. Python原生sorted与np.sort的性能对比"
231 | ]
232 | },
233 | {
234 | "cell_type": "code",
235 | "execution_count": 12,
236 | "metadata": {},
237 | "outputs": [],
238 | "source": [
239 | "arr_np = np.random.randint(0, 100, 100*10000)"
240 | ]
241 | },
242 | {
243 | "cell_type": "code",
244 | "execution_count": 13,
245 | "metadata": {},
246 | "outputs": [
247 | {
248 | "name": "stdout",
249 | "output_type": "stream",
250 | "text": [
251 | "24 ms ± 2.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
252 | ]
253 | }
254 | ],
255 | "source": [
256 | "%timeit np.sort(arr_np)"
257 | ]
258 | },
259 | {
260 | "cell_type": "code",
261 | "execution_count": 14,
262 | "metadata": {},
263 | "outputs": [],
264 | "source": [
265 | "# 将numpy arr变成python list\n",
266 | "arr_py = arr_np.tolist()"
267 | ]
268 | },
269 | {
270 | "cell_type": "code",
271 | "execution_count": 15,
272 | "metadata": {},
273 | "outputs": [
274 | {
275 | "name": "stdout",
276 | "output_type": "stream",
277 | "text": [
278 | "90.1 ms ± 726 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
279 | ]
280 | }
281 | ],
282 | "source": [
283 | "%timeit sorted(arr_py)"
284 | ]
285 | },
286 | {
287 | "cell_type": "code",
288 | "execution_count": null,
289 | "metadata": {},
290 | "outputs": [],
291 | "source": []
292 | }
293 | ],
294 | "metadata": {
295 | "kernelspec": {
296 | "display_name": "Python 3",
297 | "language": "python",
298 | "name": "python3"
299 | },
300 | "language_info": {
301 | "codemirror_mode": {
302 | "name": "ipython",
303 | "version": 3
304 | },
305 | "file_extension": ".py",
306 | "mimetype": "text/x-python",
307 | "name": "python",
308 | "nbconvert_exporter": "python",
309 | "pygments_lexer": "ipython3",
310 | "version": "3.7.6"
311 | }
312 | },
313 | "nbformat": 4,
314 | "nbformat_minor": 4
315 | }
316 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/12. Numpy中重要的广播概念-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy中重要的广播概念"
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "***广播：*** \n",
15 | "简单理解为用于不同大小数组的二元通用函数（加、减、乘等）的一组规则\n",
16 | "\n",
17 | "***广播的规则：***\n",
18 | "1. 如果两个数组的维度数dim不相同，那么小维度数组的形状将会在左边补1\n",
19 | "2. 如果shape的维度不匹配，但是有维度是1，那么可以扩展维度是1的维度匹配另一个数组；\n",
20 | "3. 如果shape的维度不匹配，但是没有任何一个维度是1，则匹配失败引发错误；"
21 | ]
22 | },
23 | {
24 | "cell_type": "code",
25 | "execution_count": 1,
26 | "metadata": {},
27 | "outputs": [],
28 | "source": [
29 | "import numpy as np"
30 | ]
31 | },
32 | {
33 | "cell_type": "markdown",
34 | "metadata": {},
35 | "source": [
36 | "### 实例1：二维数组加一维数组"
37 | ]
38 | },
39 | {
40 | "cell_type": "code",
41 | "execution_count": 2,
42 | "metadata": {},
43 | "outputs": [
44 | {
45 | "data": {
46 | "text/plain": [
47 | "array([[1., 1., 1.],\n",
48 | " [1., 1., 1.]])"
49 | ]
50 | },
51 | "execution_count": 2,
52 | "metadata": {},
53 | "output_type": "execute_result"
54 | }
55 | ],
56 | "source": [
57 | "a = np.ones((2,3))\n",
58 | "a"
59 | ]
60 | },
61 | {
62 | "cell_type": "code",
63 | "execution_count": 3,
64 | "metadata": {},
65 | "outputs": [
66 | {
67 | "data": {
68 | "text/plain": [
69 | "array([0, 1, 2])"
70 | ]
71 | },
72 | "execution_count": 3,
73 | "metadata": {},
74 | "output_type": "execute_result"
75 | }
76 | ],
77 | "source": [
78 | "b = np.arange(3)\n",
79 | "b"
80 | ]
81 | },
82 | {
83 | "cell_type": "code",
84 | "execution_count": 4,
85 | "metadata": {},
86 | "outputs": [
87 | {
88 | "data": {
89 | "text/plain": [
90 | "((2, 3), (3,))"
91 | ]
92 | },
93 | "execution_count": 4,
94 | "metadata": {},
95 | "output_type": "execute_result"
96 | }
97 | ],
98 | "source": [
99 | "a.shape, b.shape"
100 | ]
101 | },
102 | {
103 | "cell_type": "code",
104 | "execution_count": 5,
105 | "metadata": {},
106 | "outputs": [
107 | {
108 | "data": {
109 | "text/plain": [
110 | "array([[1., 2., 3.],\n",
111 | " [1., 2., 3.]])"
112 | ]
113 | },
114 | "execution_count": 5,
115 | "metadata": {},
116 | "output_type": "execute_result"
117 | }
118 | ],
119 | "source": [
120 | "# 形状不匹配但是可以相加\n",
121 | "a + b"
122 | ]
123 | },
124 | {
125 | "cell_type": "markdown",
126 | "metadata": {},
127 | "source": [
128 | "***分析：a.shape=(2, 3), b.shape=(3,)***\n",
129 | "1. 根据规则1，b.shape会变成(1, 3)\n",
130 | "2. 根据规则2，b.shape再变成(2, 3)，相当于在行上复制\n",
131 | "3. 完成匹配"
132 | ]
133 | },
134 | {
135 | "cell_type": "markdown",
136 | "metadata": {},
137 | "source": [
138 | "### 实例2：两个数组均需要广播"
139 | ]
140 | },
141 | {
142 | "cell_type": "code",
143 | "execution_count": 6,
144 | "metadata": {},
145 | "outputs": [
146 | {
147 | "data": {
148 | "text/plain": [
149 | "array([[0],\n",
150 | " [1],\n",
151 | " [2]])"
152 | ]
153 | },
154 | "execution_count": 6,
155 | "metadata": {},
156 | "output_type": "execute_result"
157 | }
158 | ],
159 | "source": [
160 | "a = np.arange(3).reshape((3, 1))\n",
161 | "a"
162 | ]
163 | },
164 | {
165 | "cell_type": "code",
166 | "execution_count": 7,
167 | "metadata": {},
168 | "outputs": [
169 | {
170 | "data": {
171 | "text/plain": [
172 | "array([0, 1, 2])"
173 | ]
174 | },
175 | "execution_count": 7,
176 | "metadata": {},
177 | "output_type": "execute_result"
178 | }
179 | ],
180 | "source": [
181 | "b = np.arange(3)\n",
182 | "b"
183 | ]
184 | },
185 | {
186 | "cell_type": "code",
187 | "execution_count": 8,
188 | "metadata": {},
189 | "outputs": [
190 | {
191 | "data": {
192 | "text/plain": [
193 | "((3, 1), (3,))"
194 | ]
195 | },
196 | "execution_count": 8,
197 | "metadata": {},
198 | "output_type": "execute_result"
199 | }
200 | ],
201 | "source": [
202 | "a.shape, b.shape"
203 | ]
204 | },
205 | {
206 | "cell_type": "code",
207 | "execution_count": 9,
208 | "metadata": {
209 | "scrolled": true
210 | },
211 | "outputs": [
212 | {
213 | "data": {
214 | "text/plain": [
215 | "array([[0, 1, 2],\n",
216 | " [1, 2, 3],\n",
217 | " [2, 3, 4]])"
218 | ]
219 | },
220 | "execution_count": 9,
221 | "metadata": {},
222 | "output_type": "execute_result"
223 | }
224 | ],
225 | "source": [
226 | "a + b"
227 | ]
228 | },
229 | {
230 | "cell_type": "markdown",
231 | "metadata": {},
232 | "source": [
233 | "***分析：a.shape为(3,1)，b.shape为(3,)***：\n",
234 | "1. 根据规则1，b.shape会变成(1, 3)\n",
235 | "2. 根据规则2，b.shape再变成(3, 3)，相当于在行上复制\n",
236 | "3. 根据规则2，a.shape再变成(3, 3)，相当于在列上复制\n",
237 | "3. 完成匹配"
238 | ]
239 | },
240 | {
241 | "cell_type": "markdown",
242 | "metadata": {},
243 | "source": [
244 | "### 实例3：不匹配的例子"
245 | ]
246 | },
247 | {
248 | "cell_type": "code",
249 | "execution_count": 10,
250 | "metadata": {},
251 | "outputs": [
252 | {
253 | "data": {
254 | "text/plain": [
255 | "array([[1., 1.],\n",
256 | " [1., 1.],\n",
257 | " [1., 1.]])"
258 | ]
259 | },
260 | "execution_count": 10,
261 | "metadata": {},
262 | "output_type": "execute_result"
263 | }
264 | ],
265 | "source": [
266 | "a = np.ones((3,2))\n",
267 | "a"
268 | ]
269 | },
270 | {
271 | "cell_type": "code",
272 | "execution_count": 11,
273 | "metadata": {},
274 | "outputs": [
275 | {
276 | "data": {
277 | "text/plain": [
278 | "array([0, 1, 2])"
279 | ]
280 | },
281 | "execution_count": 11,
282 | "metadata": {},
283 | "output_type": "execute_result"
284 | }
285 | ],
286 | "source": [
287 | "b = np.arange(3)\n",
288 | "b"
289 | ]
290 | },
291 | {
292 | "cell_type": "code",
293 | "execution_count": 12,
294 | "metadata": {},
295 | "outputs": [
296 | {
297 | "data": {
298 | "text/plain": [
299 | "((3, 2), (3,))"
300 | ]
301 | },
302 | "execution_count": 12,
303 | "metadata": {},
304 | "output_type": "execute_result"
305 | }
306 | ],
307 | "source": [
308 | "a.shape, b.shape"
309 | ]
310 | },
311 | {
312 | "cell_type": "code",
313 | "execution_count": 13,
314 | "metadata": {},
315 | "outputs": [
316 | {
317 | "ename": "ValueError",
318 | "evalue": "operands could not be broadcast together with shapes (3,2) (3,) ",
319 | "output_type": "error",
320 | "traceback": [
321 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
322 | "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)",
323 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
324 | "\u001b[1;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,2) (3,) "
325 | ]
326 | }
327 | ],
328 | "source": [
329 | "a + b"
330 | ]
331 | },
332 | {
333 | "cell_type": "markdown",
334 | "metadata": {},
335 | "source": [
336 | "***分析：a.shape为(3,2)，b.shape为(3,)***：\n",
337 | "1. 根据规则1，b.shape会变成(1, 3)\n",
338 | "2. 根据规则2，b.shape再变成(3, 3)，相当于在行上复制\n",
339 | "3. 根据规则3，形状不匹配，但是没有维度是1，匹配失败报错"
340 | ]
341 | }
342 | ],
343 | "metadata": {
344 | "kernelspec": {
345 | "display_name": "Python 3",
346 | "language": "python",
347 | "name": "python3"
348 | },
349 | "language_info": {
350 | "codemirror_mode": {
351 | "name": "ipython",
352 | "version": 3
353 | },
354 | "file_extension": ".py",
355 | "mimetype": "text/x-python",
356 | "name": "python",
357 | "nbconvert_exporter": "python",
358 | "pygments_lexer": "ipython3",
359 | "version": "3.7.6"
360 | }
361 | },
362 | "nbformat": 4,
363 | "nbformat_minor": 4
364 | }
365 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/13. Numpy求解线性方程组-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy求解线性方程组\n",
8 | "\n",
9 | "对于Ax=b，已知A和b，怎么算出x?"
10 | ]
11 | },
12 | {
13 | "cell_type": "markdown",
14 | "metadata": {},
15 | "source": [
16 | "### 1. 引入包"
17 | ]
18 | },
19 | {
20 | "cell_type": "code",
21 | "execution_count": 1,
22 | "metadata": {},
23 | "outputs": [],
24 | "source": [
25 | "import numpy as np"
26 | ]
27 | },
28 | {
29 | "cell_type": "markdown",
30 | "metadata": {},
31 | "source": [
32 | "### 2. 求解"
33 | ]
34 | },
35 | {
36 | "cell_type": "code",
37 | "execution_count": 3,
38 | "metadata": {},
39 | "outputs": [
40 | {
41 | "data": {
42 | "text/plain": [
43 | "array([[ 1, -2, 1],\n",
44 | " [ 0, 2, -8],\n",
45 | " [-4, 5, 9]])"
46 | ]
47 | },
48 | "execution_count": 3,
49 | "metadata": {},
50 | "output_type": "execute_result"
51 | }
52 | ],
53 | "source": [
54 | "A = np.array(\n",
55 | " [\n",
56 | " [1, -2, 1],\n",
57 | " [0, 2, -8],\n",
58 | " [-4, 5, 9]\n",
59 | " ]\n",
60 | ")\n",
61 | "A"
62 | ]
63 | },
64 | {
65 | "cell_type": "code",
66 | "execution_count": 5,
67 | "metadata": {},
68 | "outputs": [
69 | {
70 | "data": {
71 | "text/plain": [
72 | "array([ 0, 8, -9])"
73 | ]
74 | },
75 | "execution_count": 5,
76 | "metadata": {},
77 | "output_type": "execute_result"
78 | }
79 | ],
80 | "source": [
81 | "b = np.array([0, 8, -9])\n",
82 | "b"
83 | ]
84 | },
85 | {
86 | "cell_type": "code",
87 | "execution_count": 7,
88 | "metadata": {},
89 | "outputs": [
90 | {
91 | "data": {
92 | "text/plain": [
93 | "array([29., 16., 3.])"
94 | ]
95 | },
96 | "execution_count": 7,
97 | "metadata": {},
98 | "output_type": "execute_result"
99 | }
100 | ],
101 | "source": [
102 | "# 调用solve方法直接求解\n",
103 | "x = np.linalg.solve(A, b)\n",
104 | "x"
105 | ]
106 | },
107 | {
108 | "cell_type": "markdown",
109 | "metadata": {},
110 | "source": [
111 | "### 验证"
112 | ]
113 | },
114 | {
115 | "cell_type": "code",
116 | "execution_count": 9,
117 | "metadata": {},
118 | "outputs": [
119 | {
120 | "data": {
121 | "text/plain": [
122 | "8.0"
123 | ]
124 | },
125 | "execution_count": 9,
126 | "metadata": {},
127 | "output_type": "execute_result"
128 | }
129 | ],
130 | "source": [
131 | "# 验证单个方程\n",
132 | "A[1].dot(x)"
133 | ]
134 | },
135 | {
136 | "cell_type": "code",
137 | "execution_count": 11,
138 | "metadata": {},
139 | "outputs": [
140 | {
141 | "data": {
142 | "text/plain": [
143 | "array([ True, True, True])"
144 | ]
145 | },
146 | "execution_count": 11,
147 | "metadata": {},
148 | "output_type": "execute_result"
149 | }
150 | ],
151 | "source": [
152 | "# 验证整个矩阵计算\n",
153 | "A.dot(x) == b"
154 | ]
155 | }
156 | ],
157 | "metadata": {
158 | "kernelspec": {
159 | "display_name": "Python 3",
160 | "language": "python",
161 | "name": "python3"
162 | },
163 | "language_info": {
164 | "codemirror_mode": {
165 | "name": "ipython",
166 | "version": 3
167 | },
168 | "file_extension": ".py",
169 | "mimetype": "text/x-python",
170 | "name": "python",
171 | "nbconvert_exporter": "python",
172 | "pygments_lexer": "ipython3",
173 | "version": "3.7.6"
174 | }
175 | },
176 | "nbformat": 4,
177 | "nbformat_minor": 4
178 | }
179 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/14. Numpy实现SVD矩阵分解-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy实现SVD矩阵分解"
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "### 1. 引入包"
15 | ]
16 | },
17 | {
18 | "cell_type": "code",
19 | "execution_count": 1,
20 | "metadata": {},
21 | "outputs": [],
22 | "source": [
23 | "import numpy as np"
24 | ]
25 | },
26 | {
27 | "cell_type": "markdown",
28 | "metadata": {},
29 | "source": [
30 | "### 2. 实现矩阵分解"
31 | ]
32 | },
33 | {
34 | "cell_type": "code",
35 | "execution_count": 2,
36 | "metadata": {},
37 | "outputs": [],
38 | "source": [
39 | "A = np.random.randint(1, 10, (8, 4))"
40 | ]
41 | },
42 | {
43 | "cell_type": "code",
44 | "execution_count": 3,
45 | "metadata": {},
46 | "outputs": [
47 | {
48 | "data": {
49 | "text/plain": [
50 | "array([[6, 5, 1, 5],\n",
51 | " [1, 7, 9, 7],\n",
52 | " [7, 2, 4, 2],\n",
53 | " [6, 4, 3, 5],\n",
54 | " [2, 8, 8, 6],\n",
55 | " [5, 2, 8, 6],\n",
56 | " [7, 8, 2, 3],\n",
57 | " [1, 3, 6, 9]])"
58 | ]
59 | },
60 | "execution_count": 3,
61 | "metadata": {},
62 | "output_type": "execute_result"
63 | }
64 | ],
65 | "source": [
66 | "A"
67 | ]
68 | },
69 | {
70 | "cell_type": "code",
71 | "execution_count": 4,
72 | "metadata": {},
73 | "outputs": [],
74 | "source": [
75 | "# 实现矩阵分解\n",
76 | "U, S, V = np.linalg.svd(A, full_matrices=False)"
77 | ]
78 | },
79 | {
80 | "cell_type": "code",
81 | "execution_count": 5,
82 | "metadata": {},
83 | "outputs": [
84 | {
85 | "data": {
86 | "text/plain": [
87 | "((8, 4), (4,), (4, 4))"
88 | ]
89 | },
90 | "execution_count": 5,
91 | "metadata": {},
92 | "output_type": "execute_result"
93 | }
94 | ],
95 | "source": [
96 | "U.shape, S.shape, V.shape"
97 | ]
98 | },
99 | {
100 | "cell_type": "code",
101 | "execution_count": 6,
102 | "metadata": {},
103 | "outputs": [
104 | {
105 | "data": {
106 | "text/plain": [
107 | "array([[-0.28611227, -0.38768744, -0.07088588, -0.47757145],\n",
108 | " [-0.44374671, 0.40390585, -0.25458601, 0.20383531],\n",
109 | " [-0.24657791, -0.34884357, 0.43054458, 0.4062272 ],\n",
110 | " [-0.30673084, -0.27495123, 0.14797683, -0.2218886 ],\n",
111 | " [-0.43671345, 0.23339125, -0.39431663, 0.27599841],\n",
112 | " [-0.37257929, 0.10313032, 0.59362412, 0.23542645],\n",
113 | " [-0.33314069, -0.52514475, -0.41727103, 0.07285924],\n",
114 | " [-0.35472167, 0.38520663, 0.20225001, -0.61580222]])"
115 | ]
116 | },
117 | "execution_count": 6,
118 | "metadata": {},
119 | "output_type": "execute_result"
120 | }
121 | ],
122 | "source": [
123 | "U"
124 | ]
125 | },
126 | {
127 | "cell_type": "code",
128 | "execution_count": 7,
129 | "metadata": {},
130 | "outputs": [
131 | {
132 | "data": {
133 | "text/plain": [
134 | "array([28.44730142, 10.24874824, 6.39012419, 4.56952014])"
135 | ]
136 | },
137 | "execution_count": 7,
138 | "metadata": {},
139 | "output_type": "execute_result"
140 | }
141 | ],
142 | "source": [
143 | "# 因为是对角矩阵，这里进行了简写\n",
144 | "S"
145 | ]
146 | },
147 | {
148 | "cell_type": "code",
149 | "execution_count": 8,
150 | "metadata": {},
151 | "outputs": [
152 | {
153 | "data": {
154 | "text/plain": [
155 | "array([[28.44730142, 0. , 0. , 0. ],\n",
156 | " [ 0. , 10.24874824, 0. , 0. ],\n",
157 | " [ 0. , 0. , 6.39012419, 0. ],\n",
158 | " [ 0. , 0. , 0. , 4.56952014]])"
159 | ]
160 | },
161 | "execution_count": 8,
162 | "metadata": {},
163 | "output_type": "execute_result"
164 | }
165 | ],
166 | "source": [
167 | "np.diag(S)"
168 | ]
169 | },
170 | {
171 | "cell_type": "code",
172 | "execution_count": 9,
173 | "metadata": {},
174 | "outputs": [
175 | {
176 | "data": {
177 | "text/plain": [
178 | "array([[-0.39194862, -0.50004828, -0.54329548, -0.54877866],\n",
179 | " [-0.81202147, -0.18350883, 0.48594814, 0.26608277],\n",
180 | " [ 0.41980592, -0.84227439, 0.27814277, 0.19228481],\n",
181 | " [ 0.10373231, 0.08276523, 0.62555658, -0.76880979]])"
182 | ]
183 | },
184 | "execution_count": 9,
185 | "metadata": {},
186 | "output_type": "execute_result"
187 | }
188 | ],
189 | "source": [
190 | "V"
191 | ]
192 | },
193 | {
194 | "cell_type": "markdown",
195 | "metadata": {},
196 | "source": [
197 | "### 3. 从分量还原矩阵"
198 | ]
199 | },
200 | {
201 | "cell_type": "code",
202 | "execution_count": 10,
203 | "metadata": {},
204 | "outputs": [
205 | {
206 | "data": {
207 | "text/plain": [
208 | "array([[6., 5., 1., 5.],\n",
209 | " [1., 7., 9., 7.],\n",
210 | " [7., 2., 4., 2.],\n",
211 | " [6., 4., 3., 5.],\n",
212 | " [2., 8., 8., 6.],\n",
213 | " [5., 2., 8., 6.],\n",
214 | " [7., 8., 2., 3.],\n",
215 | " [1., 3., 6., 9.]])"
216 | ]
217 | },
218 | "execution_count": 10,
219 | "metadata": {},
220 | "output_type": "execute_result"
221 | }
222 | ],
223 | "source": [
224 | "U @ np.diag(S) @ V"
225 | ]
226 | },
227 | {
228 | "cell_type": "code",
229 | "execution_count": null,
230 | "metadata": {},
231 | "outputs": [],
232 | "source": []
233 | }
234 | ],
235 | "metadata": {
236 | "kernelspec": {
237 | "display_name": "Python 3",
238 | "language": "python",
239 | "name": "python3"
240 | },
241 | "language_info": {
242 | "codemirror_mode": {
243 | "name": "ipython",
244 | "version": 3
245 | },
246 | "file_extension": ".py",
247 | "mimetype": "text/x-python",
248 | "name": "python",
249 | "nbconvert_exporter": "python",
250 | "pygments_lexer": "ipython3",
251 | "version": "3.7.6"
252 | }
253 | },
254 | "nbformat": 4,
255 | "nbformat_minor": 4
256 | }
257 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/17. Numpy计算逆矩阵求解线性方程组-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy使用逆矩阵求解线性方程组"
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "对于这样的线性方程组：\n",
15 | "* x + y + z = 6\n",
16 | "* 2y + 5z = -4\n",
17 | "* 2x + 5y - z = 27\n",
18 | "\n",
19 | "可以表示成矩阵的形式：\n",
20 | "![](\"./other_files/numpy-array-inv.jpg\")
\n",
21 | "\n",
22 | "用公式可以表示为：Ax=b，其中A是矩阵，x和b都是列向量\n",
23 | "\n",
24 | "***逆矩阵（inverse matrix）的定义：*** \n",
25 | "设A是数域上的一个n阶矩阵，若存在另一个n阶矩阵B，使得： AB=BA=E ，则我们称B是A的逆矩阵，而A则被称为可逆矩阵。注：E为单位矩阵。\n",
26 | "\n",
27 | "***使用逆矩阵求解线性方程组的方法：*** \n",
28 | "两边都乘以$A^{-1}$，变成$A^{-1}$Ax=$A^{-1}$b，因为任何矩阵乘以单位矩阵都是自身，所以x=$A^{-1}$b"
29 | ]
30 | },
31 | {
32 | "cell_type": "code",
33 | "execution_count": 1,
34 | "metadata": {},
35 | "outputs": [],
36 | "source": [
37 | "import numpy as np"
38 | ]
39 | },
40 | {
41 | "cell_type": "markdown",
42 | "metadata": {},
43 | "source": [
44 | "### 1. 求解逆矩阵"
45 | ]
46 | },
47 | {
48 | "cell_type": "code",
49 | "execution_count": 2,
50 | "metadata": {},
51 | "outputs": [
52 | {
53 | "data": {
54 | "text/plain": [
55 | "array([[ 1, 1, 1],\n",
56 | " [ 0, 2, 5],\n",
57 | " [ 2, 5, -1]])"
58 | ]
59 | },
60 | "execution_count": 2,
61 | "metadata": {},
62 | "output_type": "execute_result"
63 | }
64 | ],
65 | "source": [
66 | "A = np.array([\n",
67 | " [1,1,1],\n",
68 | " [0,2,5],\n",
69 | " [2,5,-1]\n",
70 | "])\n",
71 | "A"
72 | ]
73 | },
74 | {
75 | "cell_type": "code",
76 | "execution_count": 3,
77 | "metadata": {},
78 | "outputs": [
79 | {
80 | "data": {
81 | "text/plain": [
82 | "array([[ 1.28571429, -0.28571429, -0.14285714],\n",
83 | " [-0.47619048, 0.14285714, 0.23809524],\n",
84 | " [ 0.19047619, 0.14285714, -0.0952381 ]])"
85 | ]
86 | },
87 | "execution_count": 3,
88 | "metadata": {},
89 | "output_type": "execute_result"
90 | }
91 | ],
92 | "source": [
93 | "# B为A的逆矩阵\n",
94 | "B = np.linalg.inv(A)\n",
95 | "B"
96 | ]
97 | },
98 | {
99 | "cell_type": "markdown",
100 | "metadata": {},
101 | "source": [
102 | "### 2. 验证矩阵和逆矩阵的乘积是单位矩阵"
103 | ]
104 | },
105 | {
106 | "cell_type": "code",
107 | "execution_count": 6,
108 | "metadata": {},
109 | "outputs": [
110 | {
111 | "data": {
112 | "text/plain": [
113 | "array([[ 1.00000000e+00, -2.77555756e-17, 2.77555756e-17],\n",
114 | " [ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00],\n",
115 | " [-2.22044605e-16, 5.55111512e-17, 1.00000000e+00]])"
116 | ]
117 | },
118 | "execution_count": 6,
119 | "metadata": {},
120 | "output_type": "execute_result"
121 | }
122 | ],
123 | "source": [
124 | "A@B"
125 | ]
126 | },
127 | {
128 | "cell_type": "code",
129 | "execution_count": 7,
130 | "metadata": {},
131 | "outputs": [
132 | {
133 | "data": {
134 | "text/plain": [
135 | "array([[ 1.00000000e+00, -2.77555756e-17, 2.77555756e-17],\n",
136 | " [ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00],\n",
137 | " [-2.22044605e-16, 5.55111512e-17, 1.00000000e+00]])"
138 | ]
139 | },
140 | "execution_count": 7,
141 | "metadata": {},
142 | "output_type": "execute_result"
143 | }
144 | ],
145 | "source": [
146 | "np.matmul(A, B)"
147 | ]
148 | },
149 | {
150 | "cell_type": "markdown",
151 | "metadata": {},
152 | "source": [
153 | "### 3. 验证线性方程组"
154 | ]
155 | },
156 | {
157 | "cell_type": "code",
158 | "execution_count": 8,
159 | "metadata": {},
160 | "outputs": [],
161 | "source": [
162 | "# 构造Ax=b中的b\n",
163 | "b = np.array([6, -4, 27])"
164 | ]
165 | },
166 | {
167 | "cell_type": "code",
168 | "execution_count": 9,
169 | "metadata": {},
170 | "outputs": [],
171 | "source": [
172 | "# 使用逆矩阵求解x\n",
173 | "x = B@b"
174 | ]
175 | },
176 | {
177 | "cell_type": "code",
178 | "execution_count": 10,
179 | "metadata": {},
180 | "outputs": [
181 | {
182 | "data": {
183 | "text/plain": [
184 | "array([ 5., 3., -2.])"
185 | ]
186 | },
187 | "execution_count": 10,
188 | "metadata": {},
189 | "output_type": "execute_result"
190 | }
191 | ],
192 | "source": [
193 | "x"
194 | ]
195 | },
196 | {
197 | "cell_type": "code",
198 | "execution_count": 12,
199 | "metadata": {},
200 | "outputs": [
201 | {
202 | "data": {
203 | "text/plain": [
204 | "array([ 6., -4., 27.])"
205 | ]
206 | },
207 | "execution_count": 12,
208 | "metadata": {},
209 | "output_type": "execute_result"
210 | }
211 | ],
212 | "source": [
213 | "# 验证A@x = b\n",
214 | "A@x"
215 | ]
216 | }
217 | ],
218 | "metadata": {
219 | "kernelspec": {
220 | "display_name": "Python 3",
221 | "language": "python",
222 | "name": "python3"
223 | },
224 | "language_info": {
225 | "codemirror_mode": {
226 | "name": "ipython",
227 | "version": 3
228 | },
229 | "file_extension": ".py",
230 | "mimetype": "text/x-python",
231 | "name": "python",
232 | "nbconvert_exporter": "python",
233 | "pygments_lexer": "ipython3",
234 | "version": "3.7.6"
235 | }
236 | },
237 | "nbformat": 4,
238 | "nbformat_minor": 4
239 | }
240 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/18. Numpy怎样将数组读写到文件-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy怎样将数组读写到文件\n",
8 | "\n",
9 | "本文档介绍的是Numpy以自己内建二进制的方式，将数组写出到文件，以及从文件加载数组；\n",
10 | "\n",
11 | "如果是文本、表格类数据，一般使用pandas这个类库做加载和处理，不用numpy\n",
12 | "\n",
13 | "几个方法：\n",
14 | "1. np.load(filename)：从.npy或者.npz文件中加载numpy数组\n",
15 | "2. np.save(filename, arr)：将单个numpy数组保存到.npy文件中\n",
16 | "3. np.savez(filename, arra=arra, arrb=arrb)：将多个numpy数组保存到.npz未压缩的文件格式中\n",
17 | "4. np.savez_compressed(filename, arra=arra, arrb=arrb)：将多个numpy数组保存到.npz压缩的文件格式中\n",
18 | "\n",
19 | ".npy和.npz都是二进制格式文件，用纯文本编辑器打开都是乱码"
20 | ]
21 | },
22 | {
23 | "cell_type": "code",
24 | "execution_count": 1,
25 | "metadata": {},
26 | "outputs": [],
27 | "source": [
28 | "import numpy as np"
29 | ]
30 | },
31 | {
32 | "cell_type": "markdown",
33 | "metadata": {},
34 | "source": [
35 | "### 1. 使用np.save和np.load保存和加载单个数组"
36 | ]
37 | },
38 | {
39 | "cell_type": "code",
40 | "execution_count": 2,
41 | "metadata": {},
42 | "outputs": [
43 | {
44 | "data": {
45 | "text/plain": [
46 | "array([[ 0, 1, 2, 3],\n",
47 | " [ 4, 5, 6, 7],\n",
48 | " [ 8, 9, 10, 11]])"
49 | ]
50 | },
51 | "execution_count": 2,
52 | "metadata": {},
53 | "output_type": "execute_result"
54 | }
55 | ],
56 | "source": [
57 | "a = np.arange(12).reshape(3,4)\n",
58 | "a"
59 | ]
60 | },
61 | {
62 | "cell_type": "code",
63 | "execution_count": 3,
64 | "metadata": {},
65 | "outputs": [],
66 | "source": [
67 | "np.save(\"arr_a.npy\", a)"
68 | ]
69 | },
70 | {
71 | "cell_type": "code",
72 | "execution_count": null,
73 | "metadata": {},
74 | "outputs": [],
75 | "source": []
76 | }
77 | ],
78 | "metadata": {
79 | "kernelspec": {
80 | "display_name": "Python 3",
81 | "language": "python",
82 | "name": "python3"
83 | },
84 | "language_info": {
85 | "codemirror_mode": {
86 | "name": "ipython",
87 | "version": 3
88 | },
89 | "file_extension": ".py",
90 | "mimetype": "text/x-python",
91 | "name": "python",
92 | "nbconvert_exporter": "python",
93 | "pygments_lexer": "ipython3",
94 | "version": "3.7.6"
95 | }
96 | },
97 | "nbformat": 4,
98 | "nbformat_minor": 4
99 | }
100 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/19. Numpy的结构化数组-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy的结构化数组"
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "一般情况下，Numpy中的数组都是同样的数据类型，比如int、float； \n",
15 | "这也是Numpy性能高效的原因，在内存中紧凑存储，读取非常快； \n",
16 | "\n",
17 | "但是Numpy也可以记录异构数组，比如下面的数据： \n",
18 | "\n",
19 | " \n",
20 | " | 姓名 | \n",
21 | " 年龄 | \n",
22 | " 体重 | \n",
23 | "
\n",
24 | " \n",
25 | " | 小王 | \n",
26 | " 30 | \n",
27 | " 80.5 | \n",
28 | "
\n",
29 | " \n",
30 | " | 小李 | \n",
31 | " 28 | \n",
32 | " 70.3 | \n",
33 | "
\n",
34 | " \n",
35 | " | 小天 | \n",
36 | " 29 | \n",
37 | " 78.6 | \n",
38 | "
\n",
39 | "
\n",
40 | "\n",
41 | "这就是本节要介绍的“Numpy结构化数组”特性； "
42 | ]
43 | },
44 | {
45 | "cell_type": "code",
46 | "execution_count": 1,
47 | "metadata": {},
48 | "outputs": [],
49 | "source": [
50 | "import numpy as np"
51 | ]
52 | },
53 | {
54 | "cell_type": "markdown",
55 | "metadata": {},
56 | "source": [
57 | "### 1. 正常的Numpy数组的dtype值只有一个类型"
58 | ]
59 | },
60 | {
61 | "cell_type": "code",
62 | "execution_count": 2,
63 | "metadata": {},
64 | "outputs": [
65 | {
66 | "data": {
67 | "text/plain": [
68 | "(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), dtype('int32'))"
69 | ]
70 | },
71 | "execution_count": 2,
72 | "metadata": {},
73 | "output_type": "execute_result"
74 | }
75 | ],
76 | "source": [
77 | "arr = np.arange(10)\n",
78 | "arr, arr.dtype"
79 | ]
80 | },
81 | {
82 | "cell_type": "code",
83 | "execution_count": 3,
84 | "metadata": {},
85 | "outputs": [
86 | {
87 | "data": {
88 | "text/plain": [
89 | "(array([[0.13813273, 0.69213455, 0.2869116 , 0.64065806],\n",
90 | " [0.5972653 , 0.42803843, 0.84914465, 0.0502318 ],\n",
91 | " [0.31351949, 0.87095862, 0.52867948, 0.83884873]]),\n",
92 | " dtype('float64'))"
93 | ]
94 | },
95 | "execution_count": 3,
96 | "metadata": {},
97 | "output_type": "execute_result"
98 | }
99 | ],
100 | "source": [
101 | "arr = np.random.rand(3, 4)\n",
102 | "arr, arr.dtype"
103 | ]
104 | },
105 | {
106 | "cell_type": "markdown",
107 | "metadata": {},
108 | "source": [
109 | "### 2. 怎样使用Numpy表达异构数据"
110 | ]
111 | },
112 | {
113 | "cell_type": "code",
114 | "execution_count": 4,
115 | "metadata": {},
116 | "outputs": [
117 | {
118 | "data": {
119 | "text/plain": [
120 | "dtype([('name', '= 29]"
314 | ]
315 | },
316 | {
317 | "cell_type": "code",
318 | "execution_count": 13,
319 | "metadata": {},
320 | "outputs": [
321 | {
322 | "data": {
323 | "text/plain": [
324 | "array([('xiaowang', 30, 80.5)],\n",
325 | " dtype=[('name', '= 29) & (my_arr[\"weight\"] > 80)]"
336 | ]
337 | },
338 | {
339 | "cell_type": "markdown",
340 | "metadata": {},
341 | "source": [
342 | "#### 对单列做逐元素计算"
343 | ]
344 | },
345 | {
346 | "cell_type": "code",
347 | "execution_count": 14,
348 | "metadata": {},
349 | "outputs": [
350 | {
351 | "data": {
352 | "text/plain": [
353 | "array([30, 28, 29])"
354 | ]
355 | },
356 | "execution_count": 14,
357 | "metadata": {},
358 | "output_type": "execute_result"
359 | }
360 | ],
361 | "source": [
362 | "my_arr[\"age\"]"
363 | ]
364 | },
365 | {
366 | "cell_type": "code",
367 | "execution_count": 15,
368 | "metadata": {},
369 | "outputs": [],
370 | "source": [
371 | "my_arr[\"age\"] += 1"
372 | ]
373 | },
374 | {
375 | "cell_type": "code",
376 | "execution_count": 16,
377 | "metadata": {},
378 | "outputs": [
379 | {
380 | "data": {
381 | "text/plain": [
382 | "array([31, 29, 30])"
383 | ]
384 | },
385 | "execution_count": 16,
386 | "metadata": {},
387 | "output_type": "execute_result"
388 | }
389 | ],
390 | "source": [
391 | "my_arr[\"age\"]"
392 | ]
393 | },
394 | {
395 | "cell_type": "markdown",
396 | "metadata": {},
397 | "source": [
398 | "最后的一言： \n",
399 | "* 对于这种每列类型不同的“异构数据”，Pandas更擅长处理；\n",
400 | "* 但我们还要学习一下Numpy结构化数组，不一定会使用它，但要能读懂别人的代码"
401 | ]
402 | }
403 | ],
404 | "metadata": {
405 | "kernelspec": {
406 | "display_name": "Python 3",
407 | "language": "python",
408 | "name": "python3"
409 | },
410 | "language_info": {
411 | "codemirror_mode": {
412 | "name": "ipython",
413 | "version": 3
414 | },
415 | "file_extension": ".py",
416 | "mimetype": "text/x-python",
417 | "name": "python",
418 | "nbconvert_exporter": "python",
419 | "pygments_lexer": "ipython3",
420 | "version": "3.7.6"
421 | }
422 | },
423 | "nbformat": 4,
424 | "nbformat_minor": 4
425 | }
426 |
--------------------------------------------------------------------------------
/.ipynb_checkpoints/20. Numpy与Pandas数据的相互转换-checkpoint.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy与Pandas数据的相互转换\n",
8 | "\n",
9 | "Pandas是在Numpy基础上建立的非常流行的数据分析类库； \n",
10 | "提供了强大针对异构、表格类型数据的处理与分析能力。\n",
11 | "\n",
12 | "本节介绍Numpy和Pandas的转换方法： \n",
13 | "1. Numpy数组怎样输入给Pandas的Series、DataFrame；\n",
14 | "2. Pandas的Series、DataFrame怎样转换成Numpy的数组"
15 | ]
16 | },
17 | {
18 | "cell_type": "code",
19 | "execution_count": 1,
20 | "metadata": {},
21 | "outputs": [],
22 | "source": [
23 | "import numpy as np\n",
24 | "import pandas as pd"
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {},
30 | "source": [
31 | "### 怎样将Numpy数组转换成Pandas的数据结构"
32 | ]
33 | },
34 | {
35 | "cell_type": "markdown",
36 | "metadata": {},
37 | "source": [
38 | "#### 怎样将Numpy的一维数组变成Pandas的Series"
39 | ]
40 | },
41 | {
42 | "cell_type": "code",
43 | "execution_count": 2,
44 | "metadata": {},
45 | "outputs": [
46 | {
47 | "data": {
48 | "text/plain": [
49 | "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
50 | ]
51 | },
52 | "execution_count": 2,
53 | "metadata": {},
54 | "output_type": "execute_result"
55 | }
56 | ],
57 | "source": [
58 | "arr = np.arange(10)\n",
59 | "arr"
60 | ]
61 | },
62 | {
63 | "cell_type": "code",
64 | "execution_count": 3,
65 | "metadata": {},
66 | "outputs": [
67 | {
68 | "data": {
69 | "text/plain": [
70 | "0 0\n",
71 | "1 1\n",
72 | "2 2\n",
73 | "3 3\n",
74 | "4 4\n",
75 | "5 5\n",
76 | "6 6\n",
77 | "7 7\n",
78 | "8 8\n",
79 | "9 9\n",
80 | "dtype: int32"
81 | ]
82 | },
83 | "execution_count": 3,
84 | "metadata": {},
85 | "output_type": "execute_result"
86 | }
87 | ],
88 | "source": [
89 | "series = pd.Series(arr)\n",
90 | "series"
91 | ]
92 | },
93 | {
94 | "cell_type": "markdown",
95 | "metadata": {},
96 | "source": [
97 | "#### 怎样将Numpy的二维数组转换成Pandas的DataFrame"
98 | ]
99 | },
100 | {
101 | "cell_type": "code",
102 | "execution_count": 4,
103 | "metadata": {},
104 | "outputs": [
105 | {
106 | "data": {
107 | "text/plain": [
108 | "array([[3, 9, 6, 3],\n",
109 | " [4, 1, 8, 1],\n",
110 | " [2, 4, 4, 7],\n",
111 | " [4, 8, 4, 7],\n",
112 | " [8, 3, 9, 8]])"
113 | ]
114 | },
115 | "execution_count": 4,
116 | "metadata": {},
117 | "output_type": "execute_result"
118 | }
119 | ],
120 | "source": [
121 | "arr = np.random.randint(1, 10, size=(5, 4))\n",
122 | "arr"
123 | ]
124 | },
125 | {
126 | "cell_type": "code",
127 | "execution_count": 5,
128 | "metadata": {},
129 | "outputs": [
130 | {
131 | "data": {
132 | "text/html": [
133 | "\n",
134 | "\n",
147 | "
\n",
148 | " \n",
149 | " \n",
150 | " | \n",
151 | " ca | \n",
152 | " cb | \n",
153 | " cc | \n",
154 | " cd | \n",
155 | "
\n",
156 | " \n",
157 | " \n",
158 | " \n",
159 | " | 0 | \n",
160 | " 3 | \n",
161 | " 9 | \n",
162 | " 6 | \n",
163 | " 3 | \n",
164 | "
\n",
165 | " \n",
166 | " | 1 | \n",
167 | " 4 | \n",
168 | " 1 | \n",
169 | " 8 | \n",
170 | " 1 | \n",
171 | "
\n",
172 | " \n",
173 | " | 2 | \n",
174 | " 2 | \n",
175 | " 4 | \n",
176 | " 4 | \n",
177 | " 7 | \n",
178 | "
\n",
179 | " \n",
180 | " | 3 | \n",
181 | " 4 | \n",
182 | " 8 | \n",
183 | " 4 | \n",
184 | " 7 | \n",
185 | "
\n",
186 | " \n",
187 | " | 4 | \n",
188 | " 8 | \n",
189 | " 3 | \n",
190 | " 9 | \n",
191 | " 8 | \n",
192 | "
\n",
193 | " \n",
194 | "
\n",
195 | "
\n",
225 | "\n",
238 | "
\n",
239 | " \n",
240 | " \n",
241 | " | \n",
242 | " ca | \n",
243 | " cb | \n",
244 | " cc | \n",
245 | " cd | \n",
246 | "
\n",
247 | " \n",
248 | " \n",
249 | " \n",
250 | " | 4 | \n",
251 | " 8 | \n",
252 | " 3 | \n",
253 | " 9 | \n",
254 | " 8 | \n",
255 | "
\n",
256 | " \n",
257 | "
\n",
258 | "
\n",
382 | "\n",
395 | "
\n",
396 | " \n",
397 | " \n",
398 | " | \n",
399 | " feature_a | \n",
400 | " feature_b | \n",
401 | " feature_c | \n",
402 | "
\n",
403 | " \n",
404 | " \n",
405 | " \n",
406 | " | 0 | \n",
407 | " 11 | \n",
408 | " 12.23 | \n",
409 | " 45.23 | \n",
410 | "
\n",
411 | " \n",
412 | " | 1 | \n",
413 | " 21 | \n",
414 | " 22.23 | \n",
415 | " 55.23 | \n",
416 | "
\n",
417 | " \n",
418 | " | 2 | \n",
419 | " 31 | \n",
420 | " 32.23 | \n",
421 | " 65.23 | \n",
422 | "
\n",
423 | " \n",
424 | " | 3 | \n",
425 | " 41 | \n",
426 | " 42.23 | \n",
427 | " 75.23 | \n",
428 | "
\n",
429 | " \n",
430 | "
\n",
431 | "
\n",
19 | " \n",
20 | " | 姓名 | \n",
21 | " 年龄 | \n",
22 | " 体重 | \n",
23 | "
\n",
24 | " \n",
25 | " | 小王 | \n",
26 | " 30 | \n",
27 | " 80.5 | \n",
28 | "
\n",
29 | " \n",
30 | " | 小李 | \n",
31 | " 28 | \n",
32 | " 70.3 | \n",
33 | "
\n",
34 | " \n",
35 | " | 小天 | \n",
36 | " 29 | \n",
37 | " 78.6 | \n",
38 | "
\n",
39 | "
\n",
40 | "\n",
41 | "这就是本节要介绍的“Numpy结构化数组”特性； "
42 | ]
43 | },
44 | {
45 | "cell_type": "code",
46 | "execution_count": 1,
47 | "metadata": {},
48 | "outputs": [],
49 | "source": [
50 | "import numpy as np"
51 | ]
52 | },
53 | {
54 | "cell_type": "markdown",
55 | "metadata": {},
56 | "source": [
57 | "### 1. 正常的Numpy数组的dtype值只有一个类型"
58 | ]
59 | },
60 | {
61 | "cell_type": "code",
62 | "execution_count": 2,
63 | "metadata": {},
64 | "outputs": [
65 | {
66 | "data": {
67 | "text/plain": [
68 | "(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), dtype('int32'))"
69 | ]
70 | },
71 | "execution_count": 2,
72 | "metadata": {},
73 | "output_type": "execute_result"
74 | }
75 | ],
76 | "source": [
77 | "arr = np.arange(10)\n",
78 | "arr, arr.dtype"
79 | ]
80 | },
81 | {
82 | "cell_type": "code",
83 | "execution_count": 3,
84 | "metadata": {},
85 | "outputs": [
86 | {
87 | "data": {
88 | "text/plain": [
89 | "(array([[0.13813273, 0.69213455, 0.2869116 , 0.64065806],\n",
90 | " [0.5972653 , 0.42803843, 0.84914465, 0.0502318 ],\n",
91 | " [0.31351949, 0.87095862, 0.52867948, 0.83884873]]),\n",
92 | " dtype('float64'))"
93 | ]
94 | },
95 | "execution_count": 3,
96 | "metadata": {},
97 | "output_type": "execute_result"
98 | }
99 | ],
100 | "source": [
101 | "arr = np.random.rand(3, 4)\n",
102 | "arr, arr.dtype"
103 | ]
104 | },
105 | {
106 | "cell_type": "markdown",
107 | "metadata": {},
108 | "source": [
109 | "### 2. 怎样使用Numpy表达异构数据"
110 | ]
111 | },
112 | {
113 | "cell_type": "code",
114 | "execution_count": 4,
115 | "metadata": {},
116 | "outputs": [
117 | {
118 | "data": {
119 | "text/plain": [
120 | "dtype([('name', '= 29]"
314 | ]
315 | },
316 | {
317 | "cell_type": "code",
318 | "execution_count": 13,
319 | "metadata": {},
320 | "outputs": [
321 | {
322 | "data": {
323 | "text/plain": [
324 | "array([('xiaowang', 30, 80.5)],\n",
325 | " dtype=[('name', '= 29) & (my_arr[\"weight\"] > 80)]"
336 | ]
337 | },
338 | {
339 | "cell_type": "markdown",
340 | "metadata": {},
341 | "source": [
342 | "#### 对单列做逐元素计算"
343 | ]
344 | },
345 | {
346 | "cell_type": "code",
347 | "execution_count": 14,
348 | "metadata": {},
349 | "outputs": [
350 | {
351 | "data": {
352 | "text/plain": [
353 | "array([30, 28, 29])"
354 | ]
355 | },
356 | "execution_count": 14,
357 | "metadata": {},
358 | "output_type": "execute_result"
359 | }
360 | ],
361 | "source": [
362 | "my_arr[\"age\"]"
363 | ]
364 | },
365 | {
366 | "cell_type": "code",
367 | "execution_count": 15,
368 | "metadata": {},
369 | "outputs": [],
370 | "source": [
371 | "my_arr[\"age\"] += 1"
372 | ]
373 | },
374 | {
375 | "cell_type": "code",
376 | "execution_count": 16,
377 | "metadata": {},
378 | "outputs": [
379 | {
380 | "data": {
381 | "text/plain": [
382 | "array([31, 29, 30])"
383 | ]
384 | },
385 | "execution_count": 16,
386 | "metadata": {},
387 | "output_type": "execute_result"
388 | }
389 | ],
390 | "source": [
391 | "my_arr[\"age\"]"
392 | ]
393 | },
394 | {
395 | "cell_type": "markdown",
396 | "metadata": {},
397 | "source": [
398 | "最后的一言： \n",
399 | "* 对于这种每列类型不同的“异构数据”，Pandas更擅长处理；\n",
400 | "* 但我们还要学习一下Numpy结构化数组，不一定会使用它，但要能读懂别人的代码"
401 | ]
402 | }
403 | ],
404 | "metadata": {
405 | "kernelspec": {
406 | "display_name": "Python 3",
407 | "language": "python",
408 | "name": "python3"
409 | },
410 | "language_info": {
411 | "codemirror_mode": {
412 | "name": "ipython",
413 | "version": 3
414 | },
415 | "file_extension": ".py",
416 | "mimetype": "text/x-python",
417 | "name": "python",
418 | "nbconvert_exporter": "python",
419 | "pygments_lexer": "ipython3",
420 | "version": "3.7.6"
421 | }
422 | },
423 | "nbformat": 4,
424 | "nbformat_minor": 4
425 | }
426 |
--------------------------------------------------------------------------------
/20. Numpy与Pandas数据的相互转换.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "## Numpy与Pandas数据的相互转换\n",
8 | "\n",
9 | "Pandas是在Numpy基础上建立的非常流行的数据分析类库； \n",
10 | "提供了强大针对异构、表格类型数据的处理与分析能力。\n",
11 | "\n",
12 | "本节介绍Numpy和Pandas的转换方法： \n",
13 | "1. Numpy数组怎样输入给Pandas的Series、DataFrame；\n",
14 | "2. Pandas的Series、DataFrame怎样转换成Numpy的数组"
15 | ]
16 | },
17 | {
18 | "cell_type": "code",
19 | "execution_count": 1,
20 | "metadata": {},
21 | "outputs": [],
22 | "source": [
23 | "import numpy as np\n",
24 | "import pandas as pd"
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {},
30 | "source": [
31 | "### 怎样将Numpy数组转换成Pandas的数据结构"
32 | ]
33 | },
34 | {
35 | "cell_type": "markdown",
36 | "metadata": {},
37 | "source": [
38 | "#### 怎样将Numpy的一维数组变成Pandas的Series"
39 | ]
40 | },
41 | {
42 | "cell_type": "code",
43 | "execution_count": 2,
44 | "metadata": {},
45 | "outputs": [
46 | {
47 | "data": {
48 | "text/plain": [
49 | "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
50 | ]
51 | },
52 | "execution_count": 2,
53 | "metadata": {},
54 | "output_type": "execute_result"
55 | }
56 | ],
57 | "source": [
58 | "arr = np.arange(10)\n",
59 | "arr"
60 | ]
61 | },
62 | {
63 | "cell_type": "code",
64 | "execution_count": 3,
65 | "metadata": {},
66 | "outputs": [
67 | {
68 | "data": {
69 | "text/plain": [
70 | "0 0\n",
71 | "1 1\n",
72 | "2 2\n",
73 | "3 3\n",
74 | "4 4\n",
75 | "5 5\n",
76 | "6 6\n",
77 | "7 7\n",
78 | "8 8\n",
79 | "9 9\n",
80 | "dtype: int32"
81 | ]
82 | },
83 | "execution_count": 3,
84 | "metadata": {},
85 | "output_type": "execute_result"
86 | }
87 | ],
88 | "source": [
89 | "series = pd.Series(arr)\n",
90 | "series"
91 | ]
92 | },
93 | {
94 | "cell_type": "markdown",
95 | "metadata": {},
96 | "source": [
97 | "#### 怎样将Numpy的二维数组转换成Pandas的DataFrame"
98 | ]
99 | },
100 | {
101 | "cell_type": "code",
102 | "execution_count": 4,
103 | "metadata": {},
104 | "outputs": [
105 | {
106 | "data": {
107 | "text/plain": [
108 | "array([[3, 9, 6, 3],\n",
109 | " [4, 1, 8, 1],\n",
110 | " [2, 4, 4, 7],\n",
111 | " [4, 8, 4, 7],\n",
112 | " [8, 3, 9, 8]])"
113 | ]
114 | },
115 | "execution_count": 4,
116 | "metadata": {},
117 | "output_type": "execute_result"
118 | }
119 | ],
120 | "source": [
121 | "arr = np.random.randint(1, 10, size=(5, 4))\n",
122 | "arr"
123 | ]
124 | },
125 | {
126 | "cell_type": "code",
127 | "execution_count": 5,
128 | "metadata": {},
129 | "outputs": [
130 | {
131 | "data": {
132 | "text/html": [
133 | "\n",
134 | "\n",
147 | "
\n",
148 | " \n",
149 | " \n",
150 | " | \n",
151 | " ca | \n",
152 | " cb | \n",
153 | " cc | \n",
154 | " cd | \n",
155 | "
\n",
156 | " \n",
157 | " \n",
158 | " \n",
159 | " | 0 | \n",
160 | " 3 | \n",
161 | " 9 | \n",
162 | " 6 | \n",
163 | " 3 | \n",
164 | "
\n",
165 | " \n",
166 | " | 1 | \n",
167 | " 4 | \n",
168 | " 1 | \n",
169 | " 8 | \n",
170 | " 1 | \n",
171 | "
\n",
172 | " \n",
173 | " | 2 | \n",
174 | " 2 | \n",
175 | " 4 | \n",
176 | " 4 | \n",
177 | " 7 | \n",
178 | "
\n",
179 | " \n",
180 | " | 3 | \n",
181 | " 4 | \n",
182 | " 8 | \n",
183 | " 4 | \n",
184 | " 7 | \n",
185 | "
\n",
186 | " \n",
187 | " | 4 | \n",
188 | " 8 | \n",
189 | " 3 | \n",
190 | " 9 | \n",
191 | " 8 | \n",
192 | "
\n",
193 | " \n",
194 | "
\n",
195 | "
\n",
225 | "\n",
238 | "
\n",
239 | " \n",
240 | " \n",
241 | " | \n",
242 | " ca | \n",
243 | " cb | \n",
244 | " cc | \n",
245 | " cd | \n",
246 | "
\n",
247 | " \n",
248 | " \n",
249 | " \n",
250 | " | 4 | \n",
251 | " 8 | \n",
252 | " 3 | \n",
253 | " 9 | \n",
254 | " 8 | \n",
255 | "
\n",
256 | " \n",
257 | "
\n",
258 | "
\n",
382 | "\n",
395 | "
\n",
396 | " \n",
397 | " \n",
398 | " | \n",
399 | " feature_a | \n",
400 | " feature_b | \n",
401 | " feature_c | \n",
402 | "
\n",
403 | " \n",
404 | " \n",
405 | " \n",
406 | " | 0 | \n",
407 | " 11 | \n",
408 | " 12.23 | \n",
409 | " 45.23 | \n",
410 | "
\n",
411 | " \n",
412 | " | 1 | \n",
413 | " 21 | \n",
414 | " 22.23 | \n",
415 | " 55.23 | \n",
416 | "
\n",
417 | " \n",
418 | " | 2 | \n",
419 | " 31 | \n",
420 | " 32.23 | \n",
421 | " 65.23 | \n",
422 | "
\n",
423 | " \n",
424 | " | 3 | \n",
425 | " 41 | \n",
426 | " 42.23 | \n",
427 | " 75.23 | \n",
428 | "
\n",
429 | " \n",
430 | "
\n",
431 | "