(四)初识NumPy(函数和图像的数组表示)

本章节主要介绍NumPy中的三个主要的函数，分别是随机函数、统计函数和梯度函数，以及一个较经典的用数组来表示图像的栗子！，希望大家能有新的收货，共同进步！

一、np.random的随机函数(1)

rand(d0,d1...,dn)　　　　　　　　　　　　　　根据d0-dn创建随机数数组，浮点数，[0,1)均匀分布；
randn(d0,d1...,dn)　　　　　　　　　　　　　根据d0-dn创建随机数数组，符合标准正态分布；
randint(low[,high,shape)　　　　　　　　　　根据shape创建随机整数或整数数组，范围是[low,high)；
seed(s)　　　　　　　　　　　　　　　　　　随机数种子，s是给定的种子值。

举个栗子：

使用rand函数随机生成3*4*5维的数组：

import numpy as np

a = np.random.rand(3, 4, 5)

print(a)

[[[0.19286829 0.43532618 0.76943415 0.70048451 0.57059645]

  [0.2879177  0.09881033 0.5569482  0.66148796 0.79611884]

  [0.31448432 0.83716575 0.41643824 0.86719307 0.03466441]

  [0.32409171 0.68495018 0.92662221 0.02462274 0.43318601]]

 [[0.03772647 0.86047162 0.22297318 0.25169961 0.04855723]

  [0.19216536 0.34209728 0.41324992 0.17463538 0.23026854]

  [0.31120323 0.34793805 0.6097682  0.26008646 0.75306371]

  [0.60755713 0.28799642 0.60235958 0.69418041 0.04996581]]

 [[0.68136971 0.27706275 0.70780751 0.49022203 0.1700511 ]

  [0.17666416 0.55479535 0.18881965 0.24248033 0.58432088]

  [0.03958541 0.34799081 0.62522536 0.66729503 0.94124187]

  [0.98251218 0.38442045 0.9647026  0.09981866 0.07480372]]]

使用randn函数随机生成3*4*5维的数组：

import numpy as np

sn = np.random.randn(3, 4, 5)

print(sn)

生成的数组符合标准正态分布：

[[[-0.97546248  0.46482237  0.46232481 -0.81607844  0.02227037]

  [ 1.41672647  0.3036927  -0.46643274  0.46203588  1.19725522]

  [-1.00459345 -1.51265022 -1.10989086 -1.73492446  0.7985382 ]

  [-0.55015804  1.75202698  0.34619959  2.10673056  1.1267265 ]]

 [[-0.52607436 -1.11950328  0.00868366  1.78641448 -1.2655594 ]

  [ 2.17963077  0.13667921  2.35539206 -0.23587487  0.89031534]

  [-0.03255321 -0.80851392  0.1731047  -2.35959613 -0.09527181]

  [-0.5231855  -0.41071298 -0.24792927  0.58756083 -0.01207484]]

 [[ 0.82598316  0.16728761  0.73248991 -1.03238179 -0.91388066]

  [ 0.53091162  0.50406905 -1.54711219 -0.44278951 -1.08371051]

  [ 0.95577053  0.8806842  -0.48579249 -0.07832728 -0.23302233]

  [ 2.38093125 -0.93528845 -0.50766876  0.81836112 -1.77913608]]]

使用seed()函数和randint()函数随机生成数组：

np.random.seed(10)

b = np.random.randint(100, 200, (3, 4))

print(b)

随机生成的数在(100,200)区间范围内：

[[109 115 164 128]

 [189 193 129 108]

 [173 100 140 136]]

再次使用seed(10)，给予同样的种子，我们可以发现产生的随机数是相同的：

import numpy as np

np.random.seed(10)

b = np.random.randint(100, 200, (3, 4))

print(b)

np.random.seed(10)

print(np.random.randint(100, 200, (3, 4)))

生成的结果一模一样如下：

[[109 115 164 128]

 [189 193 129 108]

 [173 100 140 136]]

[[109 115 164 128]

 [189 193 129 108]

 [173 100 140 136]]

二、np.randon的随机函数(2)

shuffle(a)　　　　　　　　　　　　根据数组a的第一轴进行随机排列，改变数组a；
permutation(a)　　　　　　　　　根据数组a的第一轴产生一个新的乱序数组，不改变数组a；
choice(a[,size,replace,p])　　　　　从一维数组a中以概率p抽取元素，形成size形状数组，replace表示是否可以重用元素，默认为False.

举个栗子：

首先生成随机函数，再使用shuffle函数来改变形状：

import numpy as np

a = np.random.randint(100, 200, (3, 4))

print(a)

np.random.shuffle(a)

print(a)

可以使用shuffle函数后a数组发现了变化：

[[165 136 138 198]

 [185 182 199 130]

 [123 188 114 119]]

[[123 188 114 119]

 [165 136 138 198]

 [185 182 199 130]]

再使用choice函数来举个栗子：

b = np.random.randint(100, 200, (8,))

print(b)

print(np.random.choice(b, (3, 2)))

print(np.random.choice(b, (3, 2), replace=False))

print(np.random.choice(b, (3, 2), p=b / np.sum(b)))

函数生成的结果如下：

[152 142 143 125 195 140 109 181]

[[140 109]

 [152 125]

 [109 140]]

[[195 152]

 [109 125]

 [142 181]]

[[152 143]

 [143 140]

 [142 142]]

三、np.random的随机函数(3)

uniform(low,high,size)　　　　　　　　　　　　产生具有均匀分布的数组，low起始值，high结束值，size形状；
normal(loc,scale,size)　　　　　　　　　　　　产生具有正态分布的数组，loc均值，scale标准差，size形状；
poisson(lam,size)　　　　　　　　　　　　　　产生具有泊松分布的数组，lam随机事件发生率，size形状。

举个栗子：

产生均匀分布的数组：起始值为0，结束值为10

u = np.random.uniform(0, 10, (3, 4))

print(u)

[[4.9326288  7.34687698 4.97977426 7.99871934]

 [5.00649544 5.07442334 7.18781348 7.32208848]

 [3.34763035 0.07099091 5.13151326 3.18421811]]

产生正态分布的数组，均值为10，标准差为5的数组：

n = np.random.normal(10, 5, (3, 4))

print(n)

[[ 6.8513438  11.24016929 10.4074887  16.40272973]

 [14.08424738  0.18636224  6.92151938 12.04935454]

 [16.29518527 -0.90952865 -2.54181221 20.08502763]]

四、NumPy的统计函数(基本函数)

sum(a, axis=None)　　根据给定轴axis计算数组a相关元素之后，axis为整数或元组；
mean(a, axis=None)　　　根据给定轴axis计算数组a相关元素的期望，axis为整数或元组；
average(a,axis=None,weights=None) 根据给定轴axis计算数组a相关元素的加权平均值；
std(a,axis=None) 根据给定轴axis计算数组a相关元素的标准差；
var(a,axis=None) 根据给定轴axis计算数组a相关元素的方差；

举个栗子：

求和：

import numpy as np

a = np.arange(15).reshape((3, 5))

print(np.sum(a))

结果：

1轴求期望：

print(np.mean(a, axis=1))

[ 2.  7. 12.]

0轴求期望：

print(np.mean(a, axis=0))

[5. 6. 7. 8. 9.]

0轴求加权平均值：

print(np.average(a, axis=0, weights=[10, 5, 1]))

[2.1875 3.1875 4.1875 5.1875 6.1875]

求标准差：

print(np.std(a))

4.320493798938574

求方差：

print(np.var(a))

18.666666666666668

五、NumPy的统计函数(升级)

min(a) max(a)　　　　　　　　　计算数组a中元素的最小值、最大值；
unravel_index(index,shape) 根据shape将一维下标index转换成多维下标；
ptp(a) 计算数组a中元素最大值与最小值的差；
median()　　计算数组a中元素的中位数(中值)；
argmin(a) argmax(a) 计算数组a中元素最小值、最大值的降一维后的下标。

举个栗子：

生成基础数组：

b = np.arange(15, 0, -1).reshape(3, 5)

数组中最大值：

print(np.max(b))

数组降一维后最大值对于下标：

print(np.argmax(b))

根据shape将一维下标index转换成多维下标：

print(np.unravel_index(np.argmax(b), b.shape))

求最大值和最小值之差：

print(np.ptp(b))

求数组中的中位数：

print(np.median(b))

六、NumPy的梯度函数

在NumPy中的梯度函数是np.gradient(f)，该函数能计算数组f中元素的梯度，当f为多维时，返回每个维度的梯度。

所谓的梯度指的是连续值之间的变化率，即斜率。

举个栗子：

一维数组：

生成数组：

import numpy as np

a = np.random.randint(0, 20, (5))

求该数组的梯度：

print(np.gradient(a))

结果是：

[ 2.   0.   4.   3.5 -3. ]

二维数组：

生成数组：

c = np.random.randint(0, 50, (3, 5))

求该数组的梯度：

print(np.gradient(c))

结果是：

[array([[ -9.,   4.,   7.,   0., -42.],

       [ -5.,   2.,  -7.,  11., -22.],

       [ -1.,   0., -21.,  22.,  -2.]]),

array([[-22. ,  -1. ,  -4.5,   9. ,  47. ],

       [ -9. ,   7. ,  -6.5, -15.5,   5. ],

       [ -8. ,  -3. ,   4.5,  -6. , -19. ]])]

七、图像的数组表示：

我们可以把现有的图像绘制成手绘的效果：

原始图是：

from PIL import Image

import numpy as np

a = np.asarray(Image.open('beijing.jpg').convert('L')).astype('float')

depth = 10.                         # (0-100)

grad = np.gradient(a)                # 取图像灰度的梯度值

grad_x, grad_y = grad                 # 分别取横纵图像梯度值

grad_x = grad_x*depth/100.

grad_y = grad_y*depth/100.

A = np.sqrt(grad_x**2 + grad_y**2 + 1.)

uni_x = grad_x/A

uni_y = grad_y/A

uni_z = 1./A

vec_el = np.pi/2.2                     # 光源的俯视角度，弧度值

vec_az = np.pi/4.                     # 光源的方位角度，弧度值

dx = np.cos(vec_el)*np.cos(vec_az)     # 光源对x 轴的影响

dy = np.cos(vec_el)*np.sin(vec_az)     # 光源对y 轴的影响

dz = np.sin(vec_el)                 # 光源对z 轴的影响

b = 255*(dx*uni_x + dy*uni_y + dz*uni_z)     # 光源归一化

b = b.clip(0, 255)

im = Image.fromarray(b.astype('uint8'))     # 重构图像

im.save('beijing4.jpg')

最终生成的图形效果是：

本章节的内容就分享到此，希望能帮助大家对于NumPy库有个深刻的入门！