掌握numpy(二)

目录##

掌握numpy(一)

掌握numpy(二)

掌握numpy(三)

掌握numpy(四)

数组的reshape##

顾名思义，就是对数组的形状进行改变，比如行变成列，一行变多行等。

in place###

通过使用ndarray的shape属性能够轻松的改变数组的形状，需要保证的是前后变换的size大小一样

g = np.arange(24)#生成24个数字

print(g)

>>print"Rank:", g.ndim

[ 0  1  2 ..., 21 22 23]

Rank: 1

进行变换

g.shape = (6, 4)

print(g)

>>print "Rank:", g.ndim

[[ 0  1  2  3]

 [ 4  5  6  7]

 [ 8  9 10 11]

 [12 13 14 15]

 [16 17 18 19]

 [20 21 22 23]]

Rank: 2

元素以及大小未发生变化，rank变成了2。这种转换方式g的值发生了变化，所以叫做in place转换

reshape###

reshape方法返回了一个新的数组对象，但该对象指向原始的数值，这也就意味着修改其值也将影响到原始对象，下面是例子

g = np.arange(24)

g2 = g.reshape(4,6)

>>g2

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

       [ 6,  7,  8,  9, 10, 11],

       [12, 13, 14, 15, 16, 17],

       [18, 19, 20, 21, 22, 23]])

目前g2是一个二维数组，我们可以修改其元素的值，不过与我们学过其他语言用法是a[1][2],numpy支持以下用法

g2[1, 2] = 999 #等价于g2[1][2] =999

>>g[7] #原始g的值也发生了变化

999

ravel###

既然numpy通过reshape能够将数组转换为其他的形状，那么ravel就能将数组转化为一个1维的数组

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

>>a

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

      [5, 6, 7, 8]])

>>a.ravel()

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

算数运算##

a = np.array([14, 23, 32, 41])

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

print("a + b  =", a + b)

print("a - b  =", a - b)

print("a * b  =", a * b)

print("a / b  =", a / b)

print("a // b  =", a // b)

print("a % b  =", a % b)

>>print("a ** b =", a ** b)

a + b  = [19 27 35 43]

a - b  = [ 9 19 29 39]

a * b  = [70 92 96 82]

a / b  = [  2.8          5.75        10.66666667  20.5       ]

a // b  = [ 2  5 10 20]

a % b  = [4 3 2 1]

a ** b = [537824 279841  32768   1681]

参与运算的变量需要有着相同的形状，否则会按照broadcasting形式参与运算

broadcasting##

ndarray参与运算的时候，期望变量的维度一样，如果不一样的话就会按照broadcasting规则运算

规则一###

如果数组形状不一样

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

>>a + 4

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

规则二###

沿着维度值较大的那一维度进行运算

k = np.arange(6).reshape(2, 3)

>>k + [[100], [200]]

array([[100, 201, 302],

       [103, 204, 305]])

规则三###

大小完全一样，下面的代码将会报错

k = np.arange(6).reshape(2, 3)

try:

    k + [33, 44]

except ValueError as e:

    print(e)

上转型###

经常编程的会知道转型，比如int转到long为上转，反之为下转。当两个类型不同的ndarray计算的时候，numpy默认的为上转型

k1 = np.arange(0, 5, dtype=np.uint8)

>>k1.dtype

dtype('uint8')

不同类型的参与计算

k2 = k1 + np.array([5, 6, 7, 8, 9], dtype=np.int8)

>>k2.dtype

dtype('int16')

上面结果的类型为int16（范围为-32768_32767）,实际上uint8已经足够了

k3 = k1 + 1.5

>>k3.dtype

float64

条件运算符###

条件运算符会应用到每一个元素

m = np.array([20, -5, 30, 40])

>>m < [25,25,25,25]

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

上面还可以借助broadcasting,简化写法

>>m < 25

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

如果我想通过条件运算过滤出其中的元素，那么该怎么做呢？

>>m[m<25]

array([20, -5])

如果是两个数组做对比呢？

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

b = np.array([2, 8, -1, 7])

>>np.greater(a, b) #等价与 a>b

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

>>np.maximum(a, b)

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

如果找出数组中满足某个条件的元素呢？

>>x = np.arange(9.).reshape(3, 3)

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

       [ 3.,  4.,  5.],

       [ 6.,  7.,  8.]])

>>result = np.where( x > 5 )

(array([2, 2, 2], dtype=int64), array([0, 1, 2], dtype=int64))#输出的为坐标[(2,0),(2,1),(2,2)]

如何转化为坐标形式呢？

>>list(zip(*result))

[(2, 0), (2, 1), (2, 2)]

巴特西