第11节-NumPy处理数据

创建数组：numpy.array([ ])

获取数组类型：dtype( )

import numpy as np
"""======================数组======================"""
#创建数组
a = np.array([1,2,3,4])
print('a =',a)
#多维数组
b = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(b,'\n -----------\n')
#shape获得数组的大小
print(b.dtype)
print(a.shape,b.shape,'\n -----------\n')
#修改数组的shape属性,这里b、c公用内存空间,
c = b
b.shape = 4,3
print(b,'\n -----------\n',c)
b.shape = -1,2
print(b,'\n -----------\n',c)
b.shape = 3,4
#reshape创建改变了尺寸的新数组,原数组不变
print('a =',a)
d = a.reshape((2,2))
print('a =',a,'\n',d)
#修改数组中元素
a[0] = 100
print('a =',a,'\n',d)#显示说明，修改元素值后，依然会同步发生变化
#创建数组时，指定元素类型
e = np.array([[1,2,3,4,],[5,6,7,8],[9,10,11,12]],dtype=float)
e1 = np.array([[1,2,3,4,],[5,6,7,8],[9,10,11,12]],dtype=np.complex)
print(e,'\n',e1)
"""
使用创建数组的函数创建数组
"""
#arange()函数,指定开始、结束位置和步长
f1 = np.arange(0,1,0.1)
f2= np.arange(0,1,0.2)
print(f1,'\n',f2)
#linspace()函数，指定开始、结束位置和元素个数
f3 = np.linspace(0,10,10) #包括10
f4 = np.linspace(0,10,10,endpoint = False)#不包括10
print(f3,'\n',f4)
#logspace()函数创建等比数列，指定开始、结束10的指数和元素个数
f5 = np.logspace(0,2,20)
print(f5)
#创建指定形状和类型的数组，zeros()、ones()、empty()
g = np.zeros((2,3),np.int)  #创建零值数组,指定shape和类型，默认为float型
g1 = np.ones((2,3),np.int)  #创建'1'值数组,指定shape和类型
g2 = np.empty((2,3),np.int) #创建空数组,指定shape和类型,只对其分配内存，不进行初始化
print(g,'\n',g1,'\n',g2)
#zeros_like(),ones_like(),empty_like()函数创建相同类型的数组
print(np.zeros_like(g2),'\n',np.ones_like(g2),'\n',np.empty_like(g2))

##使用frombuffer, fromstring, fromfile，fromfunction等函数可以从字节序列、文件创建数组
#第一个参数为计算每个数组元素的函数，第二个参数为数组的大小(shape)
def func(i,j):
    return (i+1)*(j+1)
h = np.fromfunction(func,(9,9))
print(h)
>>
a = [1 2 3 4]
[[ 1  2  3  4]
[ 5  6  7  8]
[ 9 10 11 12]]
-----------

int32
(4,) (3, 4)
-----------

[[ 1  2  3]
[ 4  5  6]
[ 7  8  9]
[10 11 12]]
-----------
[[ 1  2  3]
[ 4  5  6]
[ 7  8  9]
[10 11 12]]
[[ 1  2]
[ 3  4]
[ 5  6]
[ 7  8]
[ 9 10]
[11 12]]
-----------
[[ 1  2]
[ 3  4]
[ 5  6]
[ 7  8]
[ 9 10]
[11 12]]
a = [1 2 3 4]
a = [1 2 3 4]
[[1 2]
[3 4]]
a = [100   2   3   4]
[[100   2]
[  3   4]]
[[  1.   2.   3.   4.]
[  5.   6.   7.   8.]
[  9.  10.  11.  12.]]
[[  1.+0.j   2.+0.j   3.+0.j   4.+0.j]
[  5.+0.j   6.+0.j   7.+0.j   8.+0.j]
[  9.+0.j  10.+0.j  11.+0.j  12.+0.j]]
[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]
[ 0.   0.2  0.4  0.6  0.8]
[  0.           1.11111111   2.22222222   3.33333333   4.44444444
   5.55555556   6.66666667   7.77777778   8.88888889  10.        ]
[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9.]
[   1.            1.27427499    1.62377674    2.06913808    2.6366509
    3.35981829    4.2813324     5.45559478    6.95192796    8.8586679
   11.28837892   14.38449888   18.32980711   23.35721469   29.76351442
   37.92690191   48.32930239   61.58482111   78.47599704  100.        ]
[[0 0 0]
[0 0 0]]
[[1 1 1]
[1 1 1]]
[[1684340778 1634890305 1769414777]
[1612736628 1802723693 1702043744]]
[[0 0 0]
[0 0 0]]
[[1 1 1]
[1 1 1]]
[[ 541327406 1634890337  537538169]
[1629495328  544434552 1852383290]]
[[  1.   2.   3.   4.   5.   6.   7.   8.   9.]
[  2.   4.   6.   8.  10.  12.  14.  16.  18.]
[  3.   6.   9.  12.  15.  18.  21.  24.  27.]
[  4.   8.  12.  16.  20.  24.  28.  32.  36.]
[  5.  10.  15.  20.  25.  30.  35.  40.  45.]
[  6.  12.  18.  24.  30.  36.  42.  48.  54.]
[  7.  14.  21.  28.  35.  42.  49.  56.  63.]
[  8.  16.  24.  32.  40.  48.  56.  64.  72.]
[  9.  18.  27.  36.  45.  54.  63.  72.  81.]]

数组元素的存取方法,和Python的标准方法相同,利用切片和Python的列表序列不同，通过下标范围获取的新的数组是原始数组的一个视图。它与原始数组共享同一块数据空间

• 切片
• 使用整数序列

当使用整数序列对数组元素进行存取时，将使用整数序列中的每个元素作为下标，整数序列可以是列表或者数组。使用整数序列作为下标获得的数组不和原始数组共享数据空

x = np.array([1,2,3,4,5,6,7,8,9])
x1 = x[([1,3,5,7])]#下标取数组
x2 = x[::-1] #切片
print(x,'\n',x1,'\n',x2)
>>
[1 2 3 4 5 6 7 8 9]
[2 4 6 8]
[9 8 7 6 5 4 3 2 1]

• 使用布尔数组

当使用布尔数组b作为下标存取数组x中的元素时，将收集数组x中所有在数组b中对应下标为True的元素。使用布尔数组作为下标获得的数组不和原始数组共享数据空间，注意这种方式只对应于布尔数组，不能使用布尔列表

#使用布尔数组存取
x3 = x[([False,True,False,True,False,True,False,True,False])]
print(x3)
#利用下标修改元素
x2[[0,1,2]] = 7,8,9
print(x)
#之前x3已经变为4个元素
x3[[False,True,False,True]] = 6,6  #仅仅修改元素值，未存取
print(x2,'\n',x3)
#布尔数组
y = np.random.rand(10)
print(y,'\n',y>0.5,'\n',y[y>0.5])
>>
[2 4 6 8]
[1 2 3 4 5 6 9 8 7]
[7 8 9 6 5 4 3 2 1]
[2 6 6 6]
[ 0.93258857  0.40337455  0.59836769  0.69667292  0.88501452  0.35517584
  0.32490687  0.50660965  0.25548188  0.0031712 ]
[ True False  True  True  True False False  True False False]
[ 0.93258857  0.59836769  0.69667292  0.88501452  0.50660965]

多维数组

m = np.arange(0,60,10).reshape(-1,1) + np.arange(0,6)
print(m)
#切片提取,单取行或列
print(m[2],'\n',m[0:6,2:3])
print(m[1:5,1:5])
print(m[1::3,1::3])
print(m[(0,1,2,3,4,5),(0,1,2,3,4,5)])
mask = np.array([1,0,1,0,0,1],dtype=np.bool)
print(m[mask,2])
>>
[[ 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]]
[20 21 22 23 24 25]
[[ 2]
[12]
[22]
[32]
[42]
[52]]
[[11 12 13 14]
[21 22 23 24]
[31 32 33 34]
[41 42 43 44]]
[[11 14]
[41 44]]
[ 0 11 22 33 44 55]
[[ 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]]
[ 2 22 52]

结构数组

persontype = np.dtype({ 'names':['name','age','weight'],'formats':['S32','i','f']})
a6 = np.array([("Zhang",32,75.5),("Wang",24,65.2)],dtype=persontype)
print(a6.dtype)
print(a6[0],'\n',a6[1])
z = a6[0]
z["name"] = "Li"
print(a6[0]["name"])
#获取结构数组整个字段
z1 = a6[:]["age"]
print(z1)
>>
[('name', 'S32'), ('age', '<i4'), ('weight', '<f4')]
(b'Zhang', 32,  75.5)
(b'Wang', 24,  65.19999695)
b'Li'
[32 24]

• ufunc运算

通过frompyfunc()可以将计算单个值的函数转换为一个能对数组的每个元素进行计算的ufunc函数

np.frompyfunc(func,nin,nout)

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

import numpy as np
import matplotlib.pyplot as plt
def triangle_wave(x, c, c0, hc):
    x = x - int(x) # 三角波的周期为1，因此只取x坐标的小数部分进行计算
    if x >= c:
        r = 0.0
    elif x < c0:
        r = x / c0 * hc
    else:
        r = (c-x) / (c-c0) * hc
    return r
x= np.linspace(0,2,1000)
y1 = np.array([triangle_wave(t,0.8,0.6,1.0) for t in x])

plt.figure()
plt.plot(x, y1)
plt.show()
#通过frompyfunc()可以将计算单个值的函数转换为一个能对数组的每个元素进行计算的ufunc函数
triangle_ufunc1 = np.frompyfunc(triangle_wave, 4, 1)
y2 = triangle_ufunc1(x, 0.6, 0.4, 1.0)
print(y2.dtype)
triangle_ufunc2 = np.frompyfunc( lambda x:triangle_wave(x, 0.6, 0.4, 1.0), 1, 1)
y3 = triangle_ufunc2(x)
print(y3.dtype)
plt.figure()
plt.plot(x,y3)
plt.show()
>>
object
object

使用vectorize()也可以实现和frompyfunc()类似的功能，但它可以通过otypes参数指定返回数组的元素类型。otypes参数可以是一个表示元素类型的字符串，或者是一个类型列表

triangle_ufunc3 = np.vectorize(triangle_wave,otypes=[np.float])
y4 = triangle_ufunc3(x, 0.6, 0.4, 1.0)

aa = np.arange(12).reshape(2,3,2)
bb = np.arange(12,24).reshape(2,2,3)
print(aa,'\n',bb)
cc = np.dot(aa,bb)
print(cc)print(aa.shape,bb.shape,cc.shape)
>>
[[[ 0  1]  [ 2  3]  [ 4  5]]
[[ 6  7]  [ 8  9]  [10 11]]]
[[[12 13 14]  [15 16 17]]
[[18 19 20]  [21 22 23]]]
[[[[ 15  16  17]   [ 21  22  23]] 
 [[ 69  74  79]   [ 99 104 109]] 
 [[123 132 141]   [177 186 195]]]
[[[177 190 203]   [255 268 281]]  
[[231 248 265]   [333 350 367]]  
[[285 306 327]   [411 432 453]]]]
(2, 3, 2) (2, 2, 3) (2, 3, 2, 3)