[Machine Learning]Numpy

Numpy:

numpy提供两种基本的对象：ndarray和ufunc，ndarray是存储单一数据类型的多为数组，ufunc是可以对数组进行操做的函数。

1.ndarray对象

建立数组：

a = numpy.array([1, 2, 3, 4])

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

数组的形状能够经过其shape属性得到，它是一个描述数组各个轴长度的元组：

1 a.shape
2 # 结果: (4,)
3 b.shape
4 # 结果: (2, 4)

在保持数组元素个数不变的状况下，能够经过改变数组shape属性，改变数组每一个轴的大小：(数组元素在内存中的位置不变)

1 b.shape = 4,2
2 #结果
3 #array([[1, 2],
4 #       [3, 4],
5 #      [4, 5],
6 #       [6, 7]])

当设置某个轴的元素个数为-1时，将自动计算此轴的长度。使用reshape()方法能够建立指定形状的新数组，原数组保持不变，新数组和原数组是共享存储空间的，修改会相互影响：

1 c = b.reshape(2, 4)
2 #结果
3 #array([[1, 2, 3, 4],
4 #      [4, 5, 6, 7]])

数组元素的类型能够经过dtype属性得到：

c.dtype
#结果
# dtype('int64')

能够用dtype参数在建立数组时指定元素类型，float是64bit的双精度浮点类型，complex是128bit的双精度复数类型：

1 numpy.array([1,2,3,4], dtype=np.float)

Numpy的完整的类型列表存储在typeDict字典中，能够将其转换为集合来查看：

{numpy.bool_,
 numpy.object_,
 numpy.string_,
 numpy.unicode_,
 numpy.void,
 numpy.int8,
 numpy.int16,
 numpy.int32,
 numpy.int64,
 numpy.int64,
 numpy.uint8,
 numpy.uint16,
 numpy.uint32,
 numpy.uint64,
 numpy.uint64,
 numpy.float16,
 numpy.float32,
 numpy.float64,
 numpy.float128,
 numpy.datetime64,
 numpy.timedelta64,
 numpy.complex64,
 numpy.complex128,
 numpy.complex256}

arange()经过指定开始值，终止值和步长建立表示等差数列的一位数组(不包括终止值):

1 numpy.arange(0, 1, 0.1)
2 #结果
3 #array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

linspace()经过指定开始值，终止值和元素个数建立等差数列的一维数组:

1 numpy.linspace(0, 1, 10) #步长1/9
2 #结果
3 #array([ 0.        ,  0.11111111,  0.22222222,  0.33333333,  #0.44444444,
4 #        0.55555556,  0.66666667,  0.77777778,  0.88888889,  1.])
5 
6 numpy.linspace(0, 1, 10, endpoint=False) #步长1/10
7 #结果
8 #array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

 logspace()用于建立等比数列。

zeros(), ones, empty()能够建立指定形状和类型的数组, zeros_like()，ones_like(), empty_like()能够用来建立数组的形状及类型相同， 例如zeros_like(a) 和 zeros(a.shape, a.dtype)：

numpy.empty((2, 3), numpy.int) #只分配类型，不初始化
#结果
#array([[-5764607523034234880,  6917537799820997240,           4327211011],
#      [          4327214544,           4327214608,      844424930131968]])

numpy.zeros(4, numpy.float) #元素被初始化为0,默认类型numpy.float
#结果：
#array([ 0.,  0.,  0.,  0.])

frombuffer()，fromstring()和fromfile()等能够从字节序列或文件建立数组：

 1 s = "abcdefg"
 2 numpy.fromstring(s, dtype=numpy.int8)
 3 #结果:
 4 #array([ 97,  98,  99, 100, 101, 102, 103], dtype=int8)
 5 
 6 s = "abcdef"
 7 numpy.fromstring(s, dtype=numpy.int16)
 8 #结果
 9 #array([25185, 25699, 26213], dtype=int16)
10 # 其中每一个元素等于两个字节表示一个整数，98 * 256 + 97

 还能够定义一个从下标计算数值的函数，而后使用fromfunction()建立数组：

def func(i):
    return i % 4 + 1

numpy.fromfunction(func, (10, ))
#结果
#array([ 1.,  2.,  3.,  4.,  1.,  2.,  3.,  4.,  1.,  2.])

 存取元素：

a = numpy.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

a[5] #用整数做为下标能够获取数组中的某个元素
#结果：5

a[3 : 5] #用切片做为下标获取数组一部分，不包括a[5]
#结果：array([3, 4])

a[2:4]=100,101 #用下标来修改元素的值
#结果：array([  0,   1, 100, 101,   4,   5,   6,   7,   8,   9])

 经过切片获取的新数组是原数组的一个数组，它与原始数组共享同一数据空间。

使用整数列表对数组元素进行存取时，获得的新数组不和原始数组共享数据，整数数组和布尔数组相似：

1 x = numpy.arange(10, 1, -1)
2 #array([10,  9,  8,  7,  6,  5,  4,  3,  2])
3 
4 x[[3, 3, 1, 8]] #获取数组中下标为3, 3, 1, 8的四个元素，组成一个新的数组

多维数组

Numpy用元组做为数组下标，建立二维数组：

a = numpy.arange(0, 60, 10).reshape(-1, 1) + numpy.arange(0, 6)
#结果
#array([[ 0,  1,  2,  3,  4,  5],
       [10, 11, 12, 13, 14, 15],
       [20, 21, 22, 23, 24, 25],
       [30, 31, 32, 33, 34, 35],
       [40, 41, 42, 43, 44, 45],
       [50, 51, 52, 53, 54, 55]])

数据元素存取，第0个元素和数组的第0轴(纵轴)相对应，第1个元素与数组的第1轴(横轴)对应:

1 a[0, 3:5]
2 #结果：array([3, 4])
3 
4 a[4:, 4:]
5 #array([[44, 45],
6        [54, 55]])

能够经过建立下标元组，用同一元组存取多个数组：

1 idx = slice(None, None, 2), slice(2, None)
2 a[idx] #和a[::2, 2:]相同
3 #结果
4 #array([[ 2,  3,  4,  5],
5        [22, 23, 24, 25],
6        [42, 43, 44, 45]])

 

 1 1. a[(0, 1, 2, 3), (1, 2, 3, 4)] #相似a[0, 1], a[1, 2], a[2, 3], a[3, 4]
 2 #结果：array([ 1, 12, 23, 34])
 3 
 4 2. a[3:, [0, 2,5]] # 第0轴是个切片，选取第三行后的全部行，第1轴选取0， 2， 5列
 5 #结果：
 6 #array([[30, 32, 35],
 7        [40, 42, 45],
 8        [50, 52, 55]])
 9 
10 
11 3. mask = numpy.array([1, 0, 1, 0, 0, 1], dtype=numpy.bool)
12 a[mask, 2] #第0轴是个布尔数组选取0，2，5, 第1轴选取第2列
13 #结果array([ 2, 22, 52])
14 #注意：若是mask不是布尔数组，而是整数数组，列表或者元组，按照1运算

 当全部轴用形状相同的整数数组做为下标，获得的数组和下标数组的维数相同：

1 x = numpy.array([[0 ,1], [2, 3]])
2 y = numpy.array([[-1, -2], [-3, -4]])
3 a[x, y]
4 #结果：
5 # array([[ 5, 14],
6        [23, 32]])
7 
8 #相似于
9 a[(0, 1, 2, 3), (-1, -2, -3, -4)].reshape(2, 2)

 结构数组：

1 persontype = numpy.dtype({
2    ....: "names" : ["name", "age", "weight"], #每一个字段名
3    ....: "formats" : ['S32', 'i', 'f']}, align = True) #每一个字段的类型
4 
5 a = numpy.array([("zhang", 32, 75.5), ("wang", 24, 65.2)], dtype=persontype)

 2. ufunc运算

ufunc是universal function的缩写，它是一种能对数组中每一个元素进行操做的函数。

x = numpy.linspace(0, 2 * numpy.pi, 10)
y = numpy.sin(x) #numpy.sin()就是一个ufunc函数

数组提供了item()方法用来获取数组中的单个元素，并直接返回标准的Python数值类型：

1 a = numpy.arange(6.0).reshape(2, 3)
2 a.item(1, 2) #和a[1,2]相似
3 type(a.item(1, 2))
4 #结果：float
5 
6 type(a[1,2])
7 #结果：numpy.float64

四则运算

a = numpy.arange(0, 4)
b = numpy.arange(1, 5)
numpy.add(a, b)
#结果array([1, 3, 5, 7])

#能够经过指定第三个参数，保存结果
numpy.add(a, b, a) #等价于a+=b
a
#结果array([1, 3, 5, 7]) 

比较和布尔运算

使用"=="，">"等比较运算符对两个数组进行比较，将返回一个布尔数组，该数组的每一个元素值都是两个数组对于元素的比较结果：

1 numpy.array([1, 2, 3]) < numpy.array([3, 2, 1])
2 #结果array([ True, False, False], dtype=bool)

数组中的布尔运算只能经过相应的ufunc函数进行，这些函数以"logical_开头， 使用and, or, not将抛出异常"：

1 numpy.logical_and  numpy.logical_not  numpy.logical_or   numpy.logical_xor

 1 a = numpy.arange(5)
 2 b = numpy.arange(4, -1, -1)
 3 a == b
 4 #结果：array([False, False,  True, False, False], dtype=bool)
 5 
 6 a > b
 7 #结果：array([False, False, False,  True,  True], dtype=bool)
 8 
 9 numpy.logical_or(a > b, a ==b)
10 #结果：array([False, False,  True,  True,  True], dtype=bool)

 位运算符可使用&，|， ~等，也但是使用以bitwise_开头的比特运算符：

numpy.bitwise_and  numpy.bitwise_not  numpy.bitwise_or   numpy.bitwise_xor

注意位运算符优先级高于布尔运算符, 注意括号的使用：

1 (a == b) | (a > b)

自定义ufunc运算：

用frompyfunc()将一个计算单个元素的函数转换成ufunc函数, frompyfunc()的调用格式：

1 frompyfunc(func, nin, nout)

其中：func是计算单个元素的函数，nin是func输入参数的个数，nout是func返回值的个数。

 1 def triangle_wave(x, c, c0, hc):
 2     x = x - int(x)
 3     if x >= c: r= 0.0 
 4     elif x < c0: r = x/ c0 * hc
 5     else: r = (c - x) / (c - c0) * hc
 6     return r
 7 
 8 x = numpy.linspace(0, 2, 1000)
 9 #func对象
10 triangle_ufunc1 = numpy.frompyfunc(triangle_wave, 4, 1)
11 #使用
12 y2 = triangle_ufunc1(x, 0.6, 0.4, 1.0)

注意此时func返回数组的元素类型是object，能够用astype()进行转换

1 y2.dtype
2 #结果：dtype('O')
3 
4 y2 = y2.astype(numpy.float)

可使用vectorize()实现和frompyfunc()相同的功能，但该函数能够经过otypes指定返回类型。

 广播

使用ufunc对两个数组进行运算时，要求两个数组的形状相同，若是不一样，则进行广播，规则以下：

1. 让全部输入数组都向其中维数最多的数组看齐，shape属性中不足的部分经过在前面加1补齐；

2. 输出数组的shape属性是输入数组的shape属性在各轴上的最大值；

3. 若是输入数组的某个轴长度为1或与输出数组对应轴的长度相同，这个数组就能用来计算，不然出错；

4. 当输入数组的某个轴长度为1时，沿着此轴运算时都用此轴上的第一组值。

 1 a = numpy.arange(0, 60, 10).reshape(-1, 1)
 2 #结果：
 3 #array([[ 0],
 4        [10],
 5        [20],
 6        [30],
 7        [40],
 8        [50]])
 9 
10 a.shape
11 #结果：(6, 1)
12 
13 b = numpy.arange(0, 5)
14 b.shape
15 #结果 (5,)
16 
17 c = a + b
18 #结果
19 #array([[ 0,  1,  2,  3,  4],
20        [10, 11, 12, 13, 14],
21        [20, 21, 22, 23, 24],
22        [30, 31, 32, 33, 34],
23        [40, 41, 42, 43, 44],
24        [50, 51, 52, 53, 54]])
25 c.shape
26 #结果：(6, 5)

Numpy提供了快速产生能进行广播运算的数组的ogrid对象：

 1 x, y = numpy.ogrid[:5, :5]
 2 x
 3 #结果
 4 #array([[0],
 5        [1],
 6        [2],
 7        [3],
 8        [4]])
 9 y
10 #结果
11 #array([[0, 1, 2, 3, 4]])
12 
13 x + y
14 #结果
15 #array([[0, 1, 2, 3, 4],
16        [1, 2, 3, 4, 5],
17        [2, 3, 4, 5, 6],
18        [3, 4, 5, 6, 7],
19        [4, 5, 6, 7, 8]])

 多维数组:

待续。。。。。。。