Python之numpy基础（1）

numpy是Python用来做科学计算和数据分析的工具包，它具备以下特点:

numpy首先是一个多维数组，有丰富的API对多维数组进行各种矢量运算。

具备强大的“广播”能力，实现标量或低维数组与高维数组之间进行运算。

包含大量科学运算的API，例如线性代数、傅里叶变换等

不用编写循环，可以对整块数值进行标准的数学运算 这些特点，在随后的代码讲解中就可以体会到。

In [1]:

%matplotlib inline

In [2]:

from numpy.random import randn
import numpy as np
np.set_printoptions(precision=4, suppress=True) # 设置屏幕输出的格式，精度，小数点后保留的位数

1. NumPy多维数组

1.1 多维数组的创建

In [3]:

arr1 = randn(2, 3) #用numpy提供的随机数组生成器，生产一个多维数组
arr1

Out[3]:

array([[ 2.1857, -1.343 ,  0.0606],
       [-1.937 ,  0.4207,  1.9196]])

用Python内置的type()方法，看出刚才产生的是一个numpy的数组对象

In [4]:

type(arr1)

Out[4]:

numpy.ndarray

调用numpy对象内置的shape属性，可以获得数组的维度。

In [5]:

arr1.shape

Out[5]:

(2, 3)

调用numpy对象内置的dtype属性，可以获得数组元素的数据类型

In [6]:

arr1.dtype

Out[6]:

dtype('float64')

还可以把前面学过的列表list对象，转换为numpy多维数组。numpy数组和list的不同，在于numpy数组元素的数据类型是相同的，都是整型、浮点型或字符串型；而list的元素可以是各种不同类型的数据。

一个list中，包含整形和浮点型数据。转换为numpy数组后，元素都变成了浮点型。

In [7]:

lst1 = [6, 7.5, 8, 0, 1]

In [8]:

arr1 = np.array(lst1)
arr1

Out[8]:

array([ 6. ,  7.5,  8. ,  0. ,  1. ])

In [9]:

arr1.dtype

Out[9]:

dtype('float64')

元素都是整数的list，转换为numpy数组，元素都是整型。

In [10]:

lst2 = [[1, 2, 3, 4], [5, 6, 7, 8]] # 注意双重中括号
arr2 = np.array(lst2)
arr2

Out[10]:

array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

In [11]:

arr2.dtype

Out[11]:

dtype('int32')

In [12]:

arr2.ndim

Out[12]:

2

其他创建多维数组的方法

In [13]:

np.zeros(10)  #全0一维数组

Out[13]:

array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.])

In [14]:

np.zeros((2, 3)) #全0二维数组，注意参数是一个元组

Out[14]:

array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])

In [15]:

np.zeros((2, 3, 4)) #全0三维数组，注意参数是一个元组

Out[15]:

array([[[ 0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.]],

       [[ 0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.]]])

In [16]:

np.ones((2, 3))  #全1数组

Out[16]:

array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

In [17]:

np.arange(15)  # arange是Python range函数的数组版，返回数组而不是列表

Out[17]:

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

In [18]:

arr = np.empty((2,3))  # empty方法创建一个空数组（分配了一块内存空间），在没有赋值前，其元素是随机的无效数值。
arr[:] = 99   
arr

Out[18]:

array([[ 99.,  99.,  99.],
       [ 99.,  99.,  99.]])

1.2 数组的数据类型

创建数组时，可以指定元素的数据类型

In [19]:

arr1 = np.array([1, 2, 3], dtype=np.float64)
arr2 = np.array([1, 2, 3], dtype=np.int32)

In [20]:

arr1.dtype, arr2.dtype

Out[20]:

(dtype('float64'), dtype('int32'))

In [21]:

arr1

Out[21]:

array([ 1.,  2.,  3.])

In [22]:

arr2

Out[22]:

array([1, 2, 3])

1.3 数组与数组、数组与标量间的基本运算

NumPy数组与标量之间的运算，体现了前面提到的“广播”机制，会把运算传播到整个数组，不用编写循环

In [23]:

arr1 = np.array([[1., 2., 3.], [4., 5., 6.]])
arr1

Out[23]:

array([[ 1.,  2.,  3.],
       [ 4.,  5.,  6.]])

In [24]:

1 / arr1

Out[24]:

array([[ 1.    ,  0.5   ,  0.3333],
       [ 0.25  ,  0.2   ,  0.1667]])

In [25]:

arr1 * 2

Out[25]:

array([[  2.,   4.,   6.],
       [  8.,  10.,  12.]])

形状相同的数组之间的简单运算，就是对应元素的运算，不用编写循环。

In [26]:

arr1 = np.array([[1., 2., 3.], [4., 5., 6.]])
arr2 = np.array([[4, 5, 6], [1, 2, 3]])

In [27]:

arr1 + arr2

Out[27]:

array([[ 5.,  7.,  9.],
       [ 5.,  7.,  9.]])

In [28]:

arr1 - arr2

Out[28]:

array([[-3., -3., -3.],
       [ 3.,  3.,  3.]])

In [29]:

arr1 * arr2

Out[29]:

array([[  4.,  10.,  18.],
       [  4.,  10.,  18.]])

In [30]:

arr1 / arr2

Out[30]:

array([[ 0.25,  0.4 ,  0.5 ],
       [ 4.  ,  2.5 ,  2.  ]])

numpy数组与低维数组间的运算，也体现了广播机制，巧妙地把运算传播到整个数组，不用编写循环

In [31]:

arr3 = np.arange(3)
arr3

Out[31]:

array([0, 1, 2])

In [32]:

arr1 + arr3

Out[32]:

array([[ 1.,  3.,  5.],
       [ 4.,  6.,  8.]])

In [33]:

arr1 * arr3

Out[33]:

array([[  0.,   2.,   6.],
       [  0.,   5.,  12.]])

注意，这里的数组之间的乘法，与线性代数中矩阵的乘法不同。后面有专门的章节介绍“线性代数”

In [34]:

arr4 = np.array([[1],[2]])
arr4

Out[34]:

array([[1],
       [2]])

In [35]:

arr1 - arr4

Out[35]:

array([[ 0.,  1.,  2.],
       [ 2.,  3.,  4.]])

1.4 数组的索引和切片

1.4.1 一维数组

一维数组的索引和切片，跟Python的列表list的方法类似。

In [36]:

arr1 = np.arange(10)
arr1

Out[36]:

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

In [37]:

arr1[5]

Out[37]:

5

In [38]:

arr1[5:8]

Out[38]:

array([5, 6, 7])

数组的切片是源数组的视图，没有产生一个新的副本，对切片的修改，会直接反映在源数组。

In [39]:

ar2 = arr1[5:8]
arr2[1] = 12345
arr2

Out[39]:

array([[    4,     5,     6],
       [12345, 12345, 12345]])

In [40]:

arr2[:] = 64   # 对数组的切片赋值，符合数组的广播特性
arr1

Out[40]:

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

如果要把数组的切片产生新副本，需要调用copy()方法

In [41]:

arr3 = arr1[1:4].copy()
arr3[:] = 99
arr1    #没有对源数组产生改变

Out[41]:

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

1.4.2 二维数组

In [42]:

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr2d

Out[42]:

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

二维数组的索引顺序是：先行后列。如果只指定一个维度，就是行。

读取二维数组的行

In [43]:

arr2d[2]

Out[43]:

array([7, 8, 9])

行+列的索引，读取某个元素

In [44]:

arr2d[0][2]

Out[44]:

3

In [45]:

arr2d[0, 2]  # 两种索引方法等价

Out[45]:

3

冒号的使用，与list列表类似

In [46]:

arr2d[:2]

Out[46]:

array([[1, 2, 3],
       [4, 5, 6]])

In [47]:

arr2d[:2 , 1:]

Out[47]:

array([[2, 3],
       [5, 6]])

In [48]:

arr2d[1 , :2]

Out[48]:

array([4, 5])

In [49]:

arr2d[:2, 1]

Out[49]:

array([2, 5])

获取某个列或某几个列

In [50]:

arr2d[: , :1]

Out[50]:

array([[1],
       [4],
       [7]])

In [51]:

arr2d[: , :2]

Out[51]:

array([[1, 2],
       [4, 5],
       [7, 8]])

1.5 布尔型索引

布尔型索引，是指通过一个条件判断，来选取数组中元素的方法。

In [52]:

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr2d

Out[52]:

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

用一个布尔型列表，选取数组的元素

In [53]:

arr2d[[True, False, True]]

Out[53]:

array([[1, 2, 3],
       [7, 8, 9]])

选取数组中所有大于3的元素

In [54]:

arr2d[arr2d>3]

Out[54]:

array([4, 5, 6, 7, 8, 9])

1.6 花式索引

花式索引是用一个整数数组，对另一个数组进行索引。

In [55]:

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr2d

Out[55]:

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

用数组[2,0]选取到的是第2行第0行，而且，第2行排前面

In [56]:

arr2d[[2,0]]

Out[56]:

array([[7, 8, 9],
       [1, 2, 3]])

用数组[-1,2]选取到的是两个第2行，因为-1相当于第2行。这个原理在前面讲列表的时候就说过了，-i相当于“长度-i”。

In [57]:

arr2d[[-1,2]]

Out[57]:

array([[7, 8, 9],
       [7, 8, 9]])