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

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

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

1. rand(d0,d1...,dn)　　　　　　　　　　　　　　根据d0-dn建立随机数数组，浮点数，[0,1)均匀分布；
2. randn(d0,d1...,dn)　　　　　　　　　　　　　  根据d0-dn建立随机数数组，符合标准正态分布；
3. randint(low[,high,shape)　　　　　　　　　　   根据shape建立随机整数或整数数组，范围是[low,high)；
4. 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]]

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

1. shuffle(a)　　　　　　　　　　　　根据数组a的第一轴进行随机排列，改变数组a；
2. permutation(a)　　　　　　　　　   根据数组a的第一轴产生一个新的乱序数组，不改变数组a；
3. 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]]

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

1. uniform(low,high,size)　　　　　　　　　　　　产生具备均匀分布的数组，low起始值，high结束值，size形状；
2. normal(loc,scale,size)　　　　　　　　　　　　产生具备正态分布的数组，loc均值，scale标准差，size形状；
3. 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]]

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

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

举个栗子：

求和：

import numpy as np
a = np.arange(15).reshape((3, 5))
print(np.sum(a))

结果：

105

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

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

1. min(a)  max(a)　　　　　　　　　                                                            计算数组a中元素的最小值、最大值；
2. unravel_index(index,shape)                                                                        根据shape将一维下标index转换成多维下标；
3. ptp(a)                                                                                                           计算数组a中元素最大值与最小值的差；
4. median()　　                                                                                               计算数组a中元素的中位数(中值)；
5. 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))

 6、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. ]])]

 7、图像的数组表示：

咱们能够把现有的图像绘制成手绘的效果：

原始图是：

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库有个深入的入门！