Python科学计算：在Numpy的边缘试探（入门学习）

NumPy 是 Python 在科学计算领域取得成功的关键之一，如果你想通过 Python 学习数据科学或者机器学习，就必须学习 NumPy。我认为 NumPy 的功能很强大，而且入门也不难。

数组基础

创建数组

NumPy 的核心是数组（arrays）。具体来说是多维数组（ndarrays），但是我们不用管这些。通过这些数组，我们能以闪电般的速度使用像向量和数学矩阵之类的功能。赶紧捡起你的线性代数吧！（只是开玩笑，其实并不需要很多复杂的数学知识）

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 18/5/14 下午2:23
# @Author  : Wugang Li
# @File    : np.py
# @Software: PyCharm
# @license : Copyright(C), iicats.com
# @Contact : i@olei.me

import numpy as np

#创建数组
a = np.array([0,1,2,3,4])  # [0 1 2 3 4]
b = np.array([0,1,2,3,4])  # [0 1 2 3 4]
c = np.arange(5)  # [0 1 2 3 4]
d = np.linspace(0, 2 * np.pi, 5)  # [ 0.          1.57079633  3.14159265  4.71238898  6.28318531]
print(a[3])  # 3

其中的linspace的意思是：

np.linspace(start,end,num), 产生一等差数组，一共产生num个数，整个数组分成 num-1段，总长度 num-start，所以每段是unit=(num-start)/(num-1)

比如：np.linspace(0,1,12)，每个数从start开始，每次加unit. 上式是一共产生12个数，分成11段，总长12-0，所以每段12/11。所以从0开始，每次加12/11.

表示矩阵

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 18/5/15 下午2:52
# @Author  : Wugang Li
# @File    : juzhen.py
# @Software: PyCharm
# @license : Copyright(C), iicats.com
# @Contact : i@olei.me

import numpy as np

a = np.array(
    [
        [11, 12, 13, 14, 15],
        [16, 17, 18, 19, 20],
        [21, 22, 23, 24, 25],
        [26, 27, 28, 29, 30],
        [31, 32, 33, 34, 35]
    ]
)
print(a[2, 4])  # 25

b = a[0, 1:4]
print(b)  # [12,13,14]

c = a[1:4, 0]
print(c)  # [16,21,26]

d = a[::2, ::2]
print(d)
# [[11 13 15]
#  [21 23 25]
#  [31 33 35]]

e = a[:,1]
print(e)
# [12 17 22 27 32]

上面展示的了矩阵的创建，以及矩阵的切片操作~

一些方法

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 18/5/15 下午3:11
# @Author  : Wugang Li
# @File    : juzhen_method.py
# @Software: PyCharm
# @license : Copyright(C), iicats.com
# @Contact : i@olei.me

import numpy as np

a = np.array(
    [
        [11, 12, 13, 14, 15, 0],
        [16, 17, 18, 19, 20, 1],
        [21, 22, 23, 24, 25, 2],
        [26, 27, 28, 29, 30, 3],
        [31, 32, 33, 34, 35, 4]
    ]
)

print(type(a))  # <class 'numpy.ndarray'>
print(a.dtype)  # int64，总大小的字节
print(a.size)  # 30
print(a.shape)  # (5,6)，表示五行五列
print(a.itemsize)  # 每一个条目所占的字节，8bit为1字节，一个int64大小为64bite，64 / 8 = 8
print(a.ndim)  # 2，表示二维数组
print(a.nbytes)  # 240，8x30

nbytes表示这个数组中所有元素占用的字节数。你应该注意，这个数值并没有把额外的空间计算进去，因此实际上这个数组占用的空间会比这个值大点

使用数组

基本操作符

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 18/5/15 下午3:21
# @Author  : Wugang Li
# @File    : juzhen_ys.py
# @Software: PyCharm
# @license : Copyright(C), iicats.com
# @Contact : i@olei.me

import numpy as np

a = np.arange(25)

print(a)
# [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
a = a.reshape((5, 5))
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]
#  [15 16 17 18 19]
#  [20 21 22 23 24]]
print(a)

b = np.array(
    [10, 62, 1, 14, 2, 56, 79, 2, 1, 45, 4, 92, 5, 55, 63, 43, 35, 6, 53, 24, 56, 3, 56, 44, 78]
)
b = b.reshape((5, 5))
print(b)
# [[10 62  1 14  2]
#  [56 79  2  1 45]
#  [ 4 92  5 55 63]
#  [43 35  6 53 24]
#  [56  3 56 44 78]]

print(a + b)
print(b - a)
print(a * b)
print(a / b)
print(a ** 2)
print(a < b)
print(b < a)
print(a.dot(b))  # 点积，a的第一行与b的第一列对应的元素相乘的和为新产生的第一个元素
# [[ 417  380  254  446  555]
#  [1262 1735  604 1281 1615]
#  [2107 3090  954 2116 2675]
#  [2952 4445 1304 2951 3735]
#  [3797 5800 1654 3786 4795]]

其中的reshape是对原数组，进行重新分配，样式弄成多行多列的矩阵形式
dot()函数，是矩阵之间的点积
a的第一行与b的第一列对应的元素相乘的和为新产生的第一个元素，比如第一行的第一个、第二个就是：
0*10 + 1 * 56 + 2 * 4 + 3 * 43 + 4 * 56
0 * 62 + 1 * 79 + 2 * 92 + 3 * 35 + 4 * 3
还不清楚的话，看下面的这幅图：

数组的特定操作符

NumPy 还提供了一些其他很有用的操作符，用于处理数组。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 18/5/15 下午4:56
# @Author  : Wugang Li
# @File    : spectal_juzhen.py
# @Software: PyCharm
# @license : Copyright(C), iicats.com
# @Contact : i@olei.me

import numpy as np

a = np.arange(10)
print(a)

print(a.sum())  # 45
print(a.max())  # 0
print(a.min())  # 9
print(a.cumsum())  # [ 0  1  3  6 10 15 21 28 36 45]

很明显就能看出 sum()、min() 和 max() 函数的功能：将所有元素加起来，找到最小值和最大值。
cumsum() 函数就不是那么明显了。它像 sum() 那样把所有元素加起来，但是它的实现方式是，第一个元素加到第二个元素上，把结果保存到一个列表里，然后把结果加到第三个元素上，再保存到列表里，依次累加。当遍历完数组中所有元素则结束，返回值为运行数组的总和的列表。
其实 cumsum() 就是一个累加计算并且保存每次累加的结果，返回值就是包含所有累加结果的一个列表。比如 np.array([1, 2, 3, 4, 5]).cumsum() = [1, 3, 6, 10, 15]

高级索引

花俏的索引

“花俏的索引”是获取数组中我们想要的特定元素的有效方法。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 18/5/15 下午5:13
# @Author  : Wugang Li
# @File    : high_juzhen.py
# @Software: PyCharm
# @license : Copyright(C), iicats.com
# @Contact : i@olei.me

import numpy as np

a = np.arange(0, 100, 10)

print(a) # [ 0 10 20 30 40 50 60 70 80 90]

indics = [0, 1, 5, -1]
b = a[indics]
print(b) # [0，10 50 90]

布尔屏蔽（boolean masking）

布尔屏蔽是一个奇妙的特性，它允许我们根据指定条件获取数组中的元素。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 18/5/15 下午5:56
# @Author  : Wugang Li
# @File    : boolen_masking.py
# @Software: PyCharm
# @license : Copyright(C), iicats.com
# @Contact : i@olei.me

import matplotlib.pyplot as plt
import numpy as np

a = np.linspace(0, 2 * np.pi, 50)
print(a)
b = np.sin(a)
print(b)
plt.plot(a,b)
mask = b >= 0
plt.plot(a[mask], b[mask], 'bo')
mask = (b >= 0) & (a <= np.pi / 2)
plt.plot(a[mask], b[mask], 'go')
plt.show()

出现下面的图：

我们用条件式选择了图中不同的点。蓝色的点（也包含图中的绿点，只是绿点覆盖了蓝点），显示的是值大于零的点。绿点显示的是值大于 0 小于 Pi / 2 的点。

缺省索引 && Where函数

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 18/5/15 下午6:15
# @Author  : Wugang Li
# @File    : quexing_index_juzhen.py
# @Software: PyCharm
# @license : Copyright(C), iicats.com
# @Contact : i@olei.me

import numpy as np

a = np.arange(0, 100, 10)
print(a)  # [ 0 10 20 30 40 50 60 70 80 90]
b = a[:5]
c = a[a >= 50]
print(b)  # [ 0 10 20 30 40]
print(c)  # [50 60 70 80 90]

d = np.where(a < 50)
print(d)  # (array([0, 1, 2, 3, 4]),)
e = np.where(a > 50)[0]
print(e)  # [6 7 8 9]

本文作者为olei，转载请注明。

numpy python