Python基础教程学习第七日：Numpy_np..7lul9)n,oi鈥榙鈥榒l, yop

Numpy

ndarray

数组

>>> import numpy as np
>>> a = np.array([[1,2,3,4],[2,3,4,5],[3,4,5,6]])
>>> a
array([[1, 2, 3, 4],
       [2, 3, 4, 5],
       [3, 4, 5, 6]])
>>> a.dtype
dtype('int32')
>>> a.shape
(3, 4)
1
2
3
4
5
6
7
8
9
10

还可以通过给a.shape赋值来修改数组的形状，如：

>>> a.shape = (4,-1) #这里的-1表示缺省参数，自动补齐
>>> a
array([[1, 2, 3],
       [4, 2, 3],
       [4, 5, 3],
       [4, 5, 6]])
1
2
3
4
5
6
7

我们发现这只是改变了每个维度尺寸的大小，而数组元素的位置并没有发生改变，即将形状(3,4)变为(4,3)并不等同于将原数组转置。

还可以使用reshape函数来创建一个改变了原始数组形状的新数组，原始数组不变，但是新数组和原始数组共享内存区域，因此当修改了其中任意一个数组的元素时，另一个数组中对应于该位置的元素也相应的被修改了：

>>> b = a.reshape(2,-1)
>>> b
array([[1, 2, 3, 4, 2, 3],
       [4, 5, 3, 4, 5, 6]])
>>> b[0,0] = 0
>>> b
array([[0, 2, 3, 4, 2, 3],
       [4, 5, 3, 4, 5, 6]])
>>> a
array([[0, 2, 3],
       [4, 2, 3],
       [4, 5, 3],
       [4, 5, 6]])
1
2
3
4
5
6
7
8
9
10
11
12
13

除了显式的给数组的每一个元素赋值来创建数组以外，还有其他几种创建数组的方式：

>>> c = np.arange(0,1,0.1)
>>> c
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

>>> d = np.linspace(0,1,10)  #创建起点为0，终点为1，长度为10的等差数组
>>> d
array([ 0.        ,  0.11111111,  0.22222222,  0.33333333,  0.44444444,
        0.55555556,  0.66666667,  0.77777778,  0.88888889,  1.        ])

>>> e = np.logspace(0,10,10)   #创建起点为10^0，终点为10^10，长度为10的等比数组
>>> e
array([  1.00000000e+00,   1.29154967e+01,   1.66810054e+02,
         2.15443469e+03,   2.78255940e+04,   3.59381366e+05,
         4.64158883e+06,   5.99484250e+07,   7.74263683e+08,
         1.00000000e+10])

>>> f = np.zeros(3,6)
>>> f
array([[ 0., 0., 0., 0., 0., 0.],
       [ 0., 0., 0., 0., 0., 0.],
       [ 0., 0., 0., 0., 0., 0.]])

>>> g = np.empty(2, 3, 2)   #创建一个没有使用特定值来初始化的数组
>>> g
array([[[ 4.94065646e-324, 4.94065646e-324],
        [ 3.87491056e-297, 2.46845796e-130],
        [ 4.94065646e-324, 4.94065646e-324]],
       [[ 1.90723115e+083, 5.73293533e-053],
        [ -2.33568637e+124, -6.70608105e-012],
        [ 4.42786966e+160, 1.27100354e+025]]])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

类型

astype显式的把一个数组的dtype转换或投射到另外的类型：

>>> arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
>>> arr
array([ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
>>> arr.astype(np.int32)  #把浮点数转换到整形dtype，小数部分将会被截断
array([ 3, -1, -2, 0, 12, 10], dtype=int32)

>>> numeric_strings = np.array(['1.25', '-9.6', '42'], dtype=np.string_)
>>> numeric_strings.astype(float)    #一个字符窜数组表示的数字，可以使用 astype 把它们转换到数字的形式
array([ 1.25, -9.6 , 42. ])
1
2
3
4
5
6
7
8
9

ndarray的存取方式

与Python列表相似的是，ndarray也可以通过元素下标范围来获取新的数组，但是与列表不同的是，新数组与原始数组共享数据空间，因此当修改了其中任意一个数组的元素时，另一个数组中对应于该位置的元素也相应的被修改了。

>>> a = np.arange(0,10,2)
>>> a
array([0, 2, 4, 6, 8])
>>> b = a[1:-1:2]
>>> b
array([2, 6])
>>> b[0] = 3
>>> b
array([3, 6])
>>> a
array([0, 3, 4, 6, 8])
1
2
3
4
5
6
7
8
9
10
11

当使用列表或者数组的形式（统称为整数序列）来读取原数组元素来创建新数组时，两个数组就不会共享数据空间：

>>> a = np.arange(0,10,2)
>>> a
array([0, 2, 4, 6, 8])
>>> b = a[[4,3,2]]  #列表形式
>>> b
array([8, 6, 4])
>>> b [0] = 10
>>> a
array([0, 2, 4, 6, 8])
>>> c = a[np.array([4,3,2])]  #数组形式
>>> c
array([8, 6, 4])
>>> c [0] = 10
>>> a
array([0, 2, 4, 6, 8])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

也可以使用布尔数组或者布尔列表来读取原始数组元素。当使用布尔数组时，只读取True在原始数组中对应位置的元素，而使用布尔列表时，True则代表1，False代表0，也就是分别读取原始数组位置为1和0的元素：

>>> a = np.arange(0,10,2)
>>> a
array([0, 2, 4, 6, 8])
>>> b = a[np.array([True,True,False,False,True])]   #布尔数组
>>> b
array([0, 2, 8])

>>> c = a[[True,True,False,False,True]]  #布尔列表
>>> c
array([2, 2, 0, 0, 2])
1
2
3
4
5
6
7
8
9
10

同样的，这样创建的新数组也不与原始数组共享数据空间。

多维数组

多维数组即包含有多个维度，它的下标由多个数字来表示，它的存取方式和一维数组的类似。

下面就是一个多维数组的创建：

>>> np.arange(0,30,10).reshape(-1,1)+np.arange(0,3)
array([[ 0,  1,  2],
       [10, 11, 12],
       [20, 21, 22]])
1
2
3
4

在多维数组中，如果你省略了后面的索引，返回的对象将会是一个较低维的ndarray，它包括较高维度的所有数据。

>>> arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
>>> arr3d
array([[[ 1, 2, 3],
        [ 4, 5, 6]],
       [[ 7, 8, 9],
        [10, 11, 12]]])
>>> arr3d[0]
array([[1, 2, 3],
       [4, 5, 6]])
1
2
3
4
5
6
7
8
9

结构数组

>>> persontype = np.dtype({
        'names':['name', 'age', 'weight'],
        'formats':['S32','i', 'f']})
1
2
3

实际上就是先创建一个dtype对象persontype，通过其字典参数描述结构类型的各个字段。字典有两个关键字：names，formats（实际上可有names, formats, offsets, titles 四个关键字）。每个关键字对应的值都是一个列表。names定义结构中的每个字段名，而formats则定义每个字段的类型：
- S32 : 32个字节的字符串类型，由于结构中的每个元素的大小必须固定，因此需要指定字符串的长度
- i : 32bit的整数类型，相当于np.int32
- f : 32bit的单精度浮点数类型，相当于np.float32

然后我们调用array函数创建数组，通过关键字参数 dtype=persontype， 指定所创建的数组的元素类型为结构persontype。

>>> a = np.array([("Zhang",32,75.5),("Wang",24,65.2)],
        dtype=persontype)
>>> a[0]
('Zhang', 32, 75.5)
>>> a[0].dtype
dtype([('name', '|S32'), ('age', '<i4'), ('weight', '<f4')])
1
2
3
4
5
6

结构像字典一样可以通过字符串下标获取其对应的字段值：

>>> a[0]["name"]
'Zhang'
1
2

我们也可以直接获得结构数组的字段，它返回的是原始数组的视图，因此可以通过修改b[0]改变a[0][“age”]：

>>> b=a[:]["age"] # 或者a["age"]
>>> b
array([32, 24])
>>> b[0] = 40
>>> a[0]["age"]
40
1
2
3
4
5
6

转置数组和交换坐标轴

T，二维数组的转置

>>> arr = np.arange(15).reshape((3, 5))
>>> arr
array([[ 0, 1, 2, 3, 4],             
       [ 5, 6, 7, 8, 9],                      
       [10, 11, 12, 13, 14]])
>>> arr.T
array([[ 0, 5, 10],
       [ 1, 6, 11],
       [ 2, 7, 12],
       [ 3, 8, 13],
       [ 4, 9, 14]])
1
2
3
4
5
6
7
8
9
10
11

transpose，对于多维数组，可以接受用于转置的坐标轴的号码的一个元组：

>>> arr = np.arange(16).reshape((2, 2, 4))
>>> arr
array([[[ 0, 1, 2, 3],
        [ 4, 5, 6, 7]],
       [[ 8, 9, 10, 11],
        [12, 13, 14, 15]]])
>>> arr.transpose((1, 0, 2))
array([[[ 0, 1, 2, 3],
        [ 8, 9, 10, 11]],
       [[ 4, 5, 6, 7],
        [12, 13, 14, 15]]])
1
2
3
4
5
6
7
8
9
10
11