Numpy快速入门

学习地址：https://www.jianshu.com/p/38857b57effa

一.Numpy数组类ndarray

   与标准python库的数组不太一样，它包含的元素必须是相同类型的。ndarray的常见属性如下:

• ndarray.ndim:数组的轴数，表示几维的数组；
• ndarray.shape：数组的维度，返回的是一个元组，元组的长度值刚好是ndim，表示几行几列的数组；
• ndarray.size：数组元素的个数；
• ndarray.dtype：数组元素的类型；
• ndarray.itemsize：数组元素的字节大小；
• ndarray.data：数组包含的实际数据(一般情况下不会用到这个属性，都是通过索引来访问元素)

1.创建数组

（1）通过array函数，可以从普通的python列表或元组来创建，（不能是简单的元素）例：

import numpy as np

a=np.array([1,2,3])#一维数组

b=np.array([[1,2,3],[2,3,4]])#二维数组

（2）Numpy提供了一些函数来创建指定大小的数组，并用占位符来填充数组。

• zeros函数：创建初始值为0的数组
• ones函数：创建初始值为1的数组
• empty函数：创建未初始化的随机数组

  默认情况下，上面三个函数创建数组的元素类型都是float64。

（3）创建序列函数，Numpy提供了类似range函数的方法

• np.range(x,y,l),x和y代表了生成[x,y）范围每次增加步长为l的数组

• 当使用arange函数的生成float类型的序列时，用linspace函数来代替，np.linspace(x,y,l),这个代表的是生成[x,y]范围内的l个数据

2.打印数据

• 当使用print函数打印数组时，numpy会输出一个嵌套的列表形式，当数组包含的元素太多时，会省略中间的元素，只打印角落的元素，如果想禁用这个行为，强制打印所有的元素，可以开启set_printoptions选项。

• 还原成省略效果： np.set_printoptions(threshold=1000)
• 设置打印浮点数的小数位数：np.set_printoptions(precision=4) # 设置打印浮点数的小数位数，默认是8位

3.基本操作

（1）数组的算术运算会自动作用于每个元素，并返回一个新的数组，当不同类型的数组运算操作时，总是向精度更高的自动转换。例：

>>> a = np.array([20,30,40,50])

>>> b = np.arange(4)

>>> c = a - b

>>> c

array([20, 29, 38, 47])

>>> b**2

array([0, 1, 4, 9])

>>> 10 * np.sin(a)

array([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])

>>> a < 35

array([ True, True, False, False], dtype=bool)

（2）矩阵相乘，需要用dot函数

>>> a = np.array([ [1, 1], [0, 1]])

>>> b = np.array([ [2, 0],[3, 4]])

>>> a * b # 对应位置的元素相乘

array([[2, 0], [0, 4]])

>>> a.dot(b) # 矩阵乘法

array([[5, 4],[3, 4]])

>>> np.dot(a, b) # 另一种形式的矩阵乘法

array([[5, 4], [3, 4]])

（3）+=和*=是直接修改原有的数组，而不是新建一个

（4）ndarray包含了很多一元运算,默认情况下，这些操作都是作用于每一个元素，而不管它的维度。但是，我们也可以通过axis参数来限定操作的轴,axis=0代表对列操作，axis=1代表对行操作。

• a.sum()
• a.min()
• a.max()
• a.cusum()：累积和

>>> b = np.arange(12).reshape(3, 4)

>>> b

array([[ 0, 1, 2, 3],[ 4, 5, 6, 7],[ 8, 9, 10, 11]])

# 计算每一列的和

>>> b.sum(axis=0)

array([12, 15, 18, 21])

# 计算每一行的最小值

>>> b.min(axis=1)

array([0, 4, 8])

# 每一行累积和

>>> b.cumsum(axis=1)

array([[ 0, 1, 3, 6], [ 4, 9, 15, 22],[ 8, 17, 27, 38]])

（5）通用函数：sin,cos,exp

（6）索引，切片和迭代

• 一维数组的索引，切片，迭代跟普通的python列表一样。例：

>>> a = np.arange(10) ** 3

>>> a

array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])

>>> a[2]

8

>>> a[2:5]#切片的范围也是半开半闭区间

array([ 8, 27, 64])

>>> a[:6:2] # 等价于a[0:6:2]，最后一个数字是每隔两个数字取一个。

array([ 0, 8, 64])

>>> a[:6:2] = -1000

>>> a

array([-1000, 1, -1000, 27, -1000, 125, 216, 343, 512, 729])

>>> a[::-1] # 反转数组a

array([ 729, 512, 343, 216, 125, -1000, 27, -1000, 1, -1000])

• 多维数组可以在每个轴上索引，多个索引用,分隔；当索引数少于轴数时，缺失的索引认为是全切片。例：

b=array([[ 0, 1, 2, 3],[10, 11, 12, 13],[20, 21, 22, 23],[30, 31, 32, 33],[40, 41, 42, 43]])

>>> b[2,3]

23

>>> b[0:5, 1]#逗号前面的是指定要切片的行，也是半开半闭，逗号后面指定的是要切片的列

array([ 1, 11, 21, 31, 41])

>>> b[:, 1]

array([ 1, 11, 21, 31, 41])

>>> b[1:3, :]#没有指定要切的列，就把所有的列都截取下来

array([[10, 11, 12, 13],[20, 21, 22, 23]])

（7）数组的遍历：多维数组的迭代是根据第一个轴来操作的，如果想遍历每个元素，可以使用flat属性。

>>> b

array([[ 0, 1, 2, 3],

[10, 11, 12, 13],

[20, 21, 22, 23],

[30, 31, 32, 33],

[40, 41, 42, 43]])

>>> for row in b:

... print(row)

...

[0 1 2 3]

[10 11 12 13]

[20 21 22 23]

[30 31 32 33]

[40 41 42 43]

>>> for element in b.flat:#遍历每个元素

... print(element)

...

0

1

2

3

（8）shape操作

• 许多函数许多函数都可以改变数组的shape，但是它们都是返回一个新的修改后的数组，并不会改变原数组：

>>> a = np.floor(10*np.random.random((3,4)))

>>> a.shape

(3, 4)

>>> a

array([[ 7., 8., 0., 9.],

[ 8., 4., 9., 8.],

[ 4., 3., 7., 0.]])

# 返回降维的数组

>>> a.ravel()

array([ 7., 8., 0., 9., 8., 4., 9., 8., 4., 3., 7., 0.])

# 直接修改shape

>>> a.reshape(6,2) #如果一个维度为的是-1, 那么reshape函数会自动计算它的值。

array([[ 7., 8.],

[ 0., 9.],

[ 8., 4.],

[ 9., 8.],

[ 4., 3.],

[ 7., 0.]])

# 数组转置

>>> a.T

array([[ 7., 8., 4.],

[ 8., 4., 3.],

[ 0., 9., 7.],

[ 9., 8., 0.]])

>>> a.T.shape

(4, 3)

>>> a.shape

(3, 4)

• reshape返回修改后的数组，不改变数组本身，但是resize函数直接修改原数组

>>> a

array([[ 7., 8., 0., 9.],

[ 8., 4., 9., 8.],

[ 4., 3., 7., 0.]])

>>> a.resize((2,6))

>>> a

array([[ 7., 8., 0., 9., 8., 4.],

[ 9., 8., 4., 3., 7., 0.]])

（9）数组合并

>>> a = np.floor(10*np.random.random((2,2)))

>>> a

array([[ 1., 1.],

[ 4., 4.]])

>>> b = np.floor(10*np.random.random((2,2)))

>>> b

array([[ 2., 9.],

[ 0., 3.]])

>>> np.vstack((a, b))

array([[ 1., 1.],

[ 4., 4.],

[ 2., 9.],

[ 0., 3.]])

>>> np.hstack((a,b))

array([[ 1., 1., 2., 9.],

[ 4., 4., 0., 3.]])