NumPy：Numerical Python，即数值Python包，是Python进行科学计算的一个基础包，因此要更好理解和掌握Python科学计算包，尤其是pandas，需要先行掌握NumPy库的用法

from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
xsize=4
ysize=3
zsize=2
'''
#ndim 维度数量
#shape是一个表示各维度大小的元组，即数组的形状
#dtype，一个用于说明数组元素数据类型的对象
#size，元素总个数，即shape中各数组相乘
'''
a=np.array([
    [        [1,2],        [3,4],         [5,6]       ],
    [        [7, 8],       [9, 10],       [11, 12]    ],
    [        [13, 14],     [15, 16],      [17, 18]    ],
    [        [19, 20],     [21, 22],      [23, 24]    ]
])
print(a)
print(a.ndim)   #3
print(a.dtype)  #int32
print(a.shape)  #(4, 3, 2)
print(a.size)   #24
#指定narray数据类型
a=np.array([
    [        [1,2],        [3,4],         [5,6]       ],
    [        [7, 8],       [9, 10],       [11, 12]    ],
    [        [13, 14],     [15, 16],      [17, 18]    ],
    [        [19, 20],     [21, 22],      [23, 24]    ]
],dtype=float)
print(a.dtype)  #int32
#遍历Narray数组的两种方式
#遍历narray数组
for xi in a:
    print('----------------------------')
    print(xi)
    for yi in xi:
        print('###########')
        print(yi)
        for zi in yi:
            print('###########')
            print(zi)
#获取a.shape，遍历narray数组
print('for a.shape')
x,y,z= a.shape
for i in range(x):
    print('----------------------------')
    print(a[i])
    for j in range(y):
        print('*****************')
        print(a[i,j])
        for k in range(z):
            print('###########')
            print(a[i,j,k])

#array函数：接收一个普通的Python序列，转成ndarray
#zeros函数：创建指定长度或形状的全零数组
#ones函数：创建指定长度或形状的全1数组
#empty函数：创建一个没有任何具体值的数组（准确地说是一些未初始化的垃圾值）
a=[1,2,3,4,5]
b=(6,7,8,9,10)
c=np.array(a)
print('[1,2,3,4,5]=\n',c)
c=np.array(b)
print('(6,7,8,9,10)=\n',c)
z=np.zeros((xsize,ysize),dtype=float)
print('np.zeros((xsize,ysize),dtype=float)=\n',z)
z=np.ones((xsize,ysize),dtype=float)
print('np.ones((xsize,ysize),dtype=float)=\n',z)
z=np.empty((xsize,ysize),dtype=float)
print('np.empty((xsize,ysize),dtype=float)=\n',z)
#arrange函数：类似于python的range函数，通过指定开始值、终值和步长来创建一维数组，注意数组不包括终值
#linspace函数：通过指定开始值、终值和元素个数来创建一维数组，可以通过endpoint关键字指定是否包括终值，缺省设置是包括终值
#logspace函数：和linspace类似，不过它创建等比数列使用随机数填充数组，即使用numpy.random模块的random()函数，数组所包含的的元素数量由参数决定
z=np.arange(20)
print('np.arange(20)=',z)
z=np.arange(,20)
print('np.arange(0,20)=',z)
z=np.arange(,20,1)
print('np.arange(0,20,1)=',z)
z=np.arange(,20,2)
print('np.arange(0,20,2)=',z)
z=np.arange(,20,2).reshape(2,5)
print('np.arange(0,20,2).reshape(2,5)=',z)
z=np.arange(,20,2).reshape(5,2)
print('np.arange(0,20,2).reshape(5,2)=',z)
z=np.arange(,20,2).reshape(5,-1)
print('np.arange(0,20,2).reshape(5,-1)=',z)
z=np.linspace(1,10,5)
print('np.linspace(1,10,5)=',z)
z=np.linspace(1,10,7)
print('np.linspace(1,10,7)=',z)
a=range(z.size)
plt.plot(a,z)
plt.show()
z=np.logspace(,2,5)
print('np.logspace(0,2,5)=',z)
a=range(z.size)
plt.plot(a,z)
plt.show()
z=np.logspace(,2)
print('np.logspace(0,2)=',z)
a=range(z.size)
plt.plot(a,z)
plt.show()
z=np.random.random((xsize))
print('np.random.random((xsize))=',z)
z=np.random.random((xsize,ysize))
print('np.random.random((xsize,ysize))=',z)
a=np.array([1,2,3,4,5])
print('np.array([1,2,3,4,5]).dtype=',a.dtype)
z=a.astype(float)
print('a.astype(float)=',z.dtype)
#NumPy中所支持的数据类型,数据类型类型代码说明
#int_ 默认整型（与C中的long相同，通常为int64或者int32）
#intc 完全等同于C中的long（通常为int64或者int32）
#intp 表示索引的整型，与C中的size_t相同，通常为int64或者int32
#int8 i1 字节（-128 ~ 127），1个字节
#int16 i2 整型（-32768 ~ 32767），2个字节
#int32 i4 整型（-2147483648 ~ 2147483647），4个字节
#int64 i8 整型（- 9223372036854775808~9223372036854775807），8字节
#uint8 u1 无符号整型（0~255）
#uint16 u2 无符号整型（0~65535）
#uint32 u4 无符号整型（0~4294967295）
#uint64 u8 无符号整型（0 ~ 18446744073709551615
#float_ float64的简写形式
#float16 f2 半精度浮点型：符号位，5位指数，10位小数部分
#float32 f4或者f 半精度浮点型：符号位，8位指数，23位小数部分
#float64 f8或者d 半精度浮点型：符号位，11位指数，52位小数部分
#float128 f16或者g 扩展精度浮点数
#complex_ c16 complex128的简写形式
#complex64 c8 复数，由两个32位的浮点数来表示（实数部分和虚数部分）
#complex128 c16 复数，由两个64位的浮点数来表示（实数部分和虚数部分）
#bool_ 以一个字节形式存储的布尔值（True或者False）
#bool ? 存储True和False值的布尔类型
#object O Python对象类型
#String_ S 固定长度的字符串类型（每个字符1个字节）。例如要创建一个长度为8的字符串，应使用S8
#Unicode_ U 固定长度的unicode类型
a=np.arange(,20,2)
print('a=',a)
print('a.reshape(2,5)=',a.reshape(2,5))
print('a.reshape(-1,5)=',a.reshape(-1,5))
b=a.reshape(2,-1)
print('b=',b)
#数组与标量、数组之间的运算
#数组的矩阵积（matrix product）
#数组的索引与切片
#数组转置与轴对换
#通用函数：快速的元素级数组函数
#聚合函数
#np.where函数
#np.unique函数
#--------------数组与标量之间的运算-----------
a=np.array([range(1,6)])
b=np.array([range(6,11)])
print('np.array([range(0,5)])=',a)
print('np.array([range(5,10)])=',b)
print('a+2=',a+2)
print('a-2=',a-2)
print('a*2=',a*2)
print('a/2=',a/2)
print('1/a=',1/a)
print('a**2=',a**2)
#----------大小相等的数组之间的运算---------
a=np.array([range(1,11)]).reshape(2,5)
b=np.array([range(11,21)]).reshape(2,5)
print('np.array([range(1,11)]).reshape(2,5)=\n',a)
print('np.array([range(11,21)]).reshape(2,5)=\n',b)
print('a+b',a+b)
print('a-b',a-b)
print('a*b',a*b)
print('a/b',a/b)
#----------数组的矩阵积（matrix product）--------
#两个二维矩阵（多维数组即矩阵）满足个矩阵的列数与第二个矩阵的行数相同，那么可以进行矩阵乘法，即矩阵积，矩阵积不是元素级的运算
#两个矩阵相乘结果所得到的的数组中每个元素为，个矩阵中与该元素行号相同的元素与第二个矩阵中与该元素列号相同的元素，两两相乘后求和
a=np.array([range(1,16)]).reshape(5,3)
b=np.array([range(1,13)]).reshape(3,4)
print('a=\n',a)
print('b=\n',b)
print('a.dot(b)=\n',a.dot(b))
print('np.dot(a,b)=\n',np.dot(a,b))
print(a.shape,b.shape,a.dot(b).shape)
#----------数组的索引与切片-----------
#多维数组的索引
#NumPy中数组的切片
#布尔型索引
#花式索引
#获取Narray数组切片
a=np.array([
    [        [1,2],        [3,4],         [5,6]       ],
    [        [7, 8],       [9, 10],       [11, 12]    ],
    [        [13, 14],     [15, 16],      [17, 18]    ],
    [        [19, 20],     [21, 22],      [23, 24]    ]
])
print('a[0]=',a[])
print('a[1]=',a[1])
print('a[2]=',a[2])
print('a[0:2]=',a[:2])
print('a[-1]=',a[-1])
print('a[1,2]=',a[1,2])
print('a[1][2]=',a[1][2])
print('a[:][2]=',a[:][2])
print('a[:,2]=',a[:,2])
print('a[:,0:2]=',a[:,:2])
print('a[1][0:2][1]=',a[1][:2][1])
print('a[:][0:2][1]=',a[:][:2][1])
print('a[:,2,1]=',a[:,2,1])
print('a[:,0:2,:1]=',a[:,:2,:1])
#布尔型索引
a=np.random.random((4,4))*20
#[[ 1 15 17 11] [ 8 14  9  0] [18  3  9  7] [13 10  1 13]]
a=a.astype(int)
print(a)
print('a<5',a<5)
#[[ True False False False] [False False False  True] [False  True False False] [False False  True False]]
print('[a<5]',a[a<5])
#[1 0 3 1]
b=np.array(['Tom','John','Tony'])
print('b=',b)                         # ['Tom' 'John' 'Tony']
print('b=="John"=',b=='John')       # [False  True False]
a=np.array([range(1,13)]).reshape(3,4) #[[ 1  2  3  4] [ 5  6  7  8] [ 9 10 11 12]]
print('a=',a)
print('a[b=="John"]=',a[b=="John"]) #[[5 6 7 8]]
print('a[b=="John",0:2]=',a[b=="John",:2]) #[[5 6]]
print('b=="John" | b=="Tony"=',(b=='John')|(b=='Tony'))       # [False  True True]
print('~((b=="John")|(b=="Tony"))=',~((b=='John')|(b=='Tony')))       # [ True False False]
print('b=="John" & b=="Tony"=',(b=='John')&(b=='Tony'))       # [False  False False]
print('a[~(b=="John"]=',a[~(b=="John")])                        #[[ 1  2  3  4] [ 9 10 11 12]]
print('a[~(b=="John"|(b=="Tony")]=',a[~((b=="John")|(b=="Tony"))])  #[[1 2 3 4]]
#花式索引
a=np.arange(32).reshape(8,4)
print('np.arange(32).reshape(8,4)=',a)
#print('a[0,3,5]=',a[0,3,5])  #error
print('a[[1,3,5]]=',a[[1,3,5]])  #[[ 4  5  6  7][12 13 14 15] [20 21 22 23]]
print('a[np.ix_([1,3,5])]=',a[np.ix_([1,3,5])]) #[[ 4  5  6  7] [12 13 14 15] [20 21 22 23]]
print('a[np.ix_([1,3,5],[0,2,3])]=',a[np.ix_([1,3,5],[,2,3])]) #[[ 4  6  7] [12 14 15] [20 22 23]]
#数组转置与轴转换
a=np.arange(12).reshape(4,3)
print('a=',a)   #[[ 0  1  2] [ 3  4  5] [ 6  7  8] [ 9 10 11]]
print('a.transpose()=',a.transpose()) #[[ 0  3  6  9] [ 1  4  7 10] [ 2  5  8 11]]
print('a.T=',a.T) #[[ 0  3  6  9] [ 1  4  7 10] [ 2  5  8 11]]
#-----------------一元通用函数---------------------
#abs,fabs 计算整数、浮点数或复数的值。对于非复数值，可以使用更快的fabs
#sqrt 计算各元素的平方根，相当于 arr ** 0.5
#square 计算各元素的平方，相当于arr ** 2
#exp 计算各元素的指数e的x次方log, log10, log2,log1p分别为自然对数、底数是10的log，底数为2的log，log(1+x)
#sign 计算各元素的正负号：1 正数，0 零 ， -1 负数
#cell 计算各元素的ceiling值，即大于等于该值的小整数
#floor 计算各元素的floor值，即小于等于该值的大整数
#rint 将各元素值四舍五入到接近的整数，保留dtype
#modf 将数组的小数位和整数部分以两个独立数组的形式返回
#isnan 返回一个表示“哪些值是NaN（不是一个数字）”的布尔类型数组
#isfinite，isinf 分别返回一个表示“哪些元素是有穷的（非inf，非NaN）”或“哪些元素是无穷的”的布尔型数组
#cos、cosh、sin、sinh、tan、tanh普通型和双曲型三角函数
#arccos,arccosh,arcsin、arctan、arctanh反三角函数
#logical_not 计算各元素not x的真值，相当于 ~ 和 -arr
#-----------------二元通用函数---------------------
#add 将数组中相同位置对应的元素相加
#substract 从个数组中减去第二个数组中的元素
#multiply 数组元素相乘
#divide、floor_divive除法或者向下圆整除法（丢弃余数）
#pow 对个数组中的元素A，根据第二个数组中的相应元素B，计算A的B次方
#maximum、fmax 元素级别的大值，fmax会忽略NaN
#minimum、fmin 元素级别的小值，fmin会忽略NaN
#mod 元素级的求模（除法的余数）
#copysign 将第二个数组中的值的符号复制给个数组中对应位置的值
#greater、greater_equal、less、less_equal、equal、not_equal执行元素级别的比较运算，终产生布尔型数组
#logical_and、logical_or、logical_xor执行元素级别的布尔逻辑运算，相当于中缀运算符&、|、^
a=np.arange(1,7).reshape(2,3)
b=np.arange(7,13).reshape(2,3)
print('np.sqrt(a)=',np.sqrt(a)) #[[0.         1.         1.41421356] [1.73205081 2.         2.23606798]]
print('np.square(a)=',np.square(a)) #
print('np.cos(a)=',np.cos(a)) #
print('np.rint(a)=',np.rint(a)) #
print('np.log10(b)=',np.log10(b)) #
#print(np.pow(a,b))
#print(np.mod(a,b))
#print(np.greater(a,b))
#聚合函数
#聚合函数是对一组值（比如一个数组）进行操作，返回一个单一值作为结果的函数。因此求数组所有元素之和、求所有元素的大小值以及标准差的函数就是聚合函数
a=np.array(range(1,10))
print('a.min()=',a.min())
print('a.max()=',a.max())
print('a.sum()=',a.sum())
print('a.mean()=',a.mean())
print('a.std()=',a.std())
#聚合函数可以指定对数值的某个轴元素进行操作
a=np.array([range(1,13)]).reshape(3,4)
print('a=',a)
print('a.mean(axis=0)',a.mean(axis=))
print('a.max(axis=0)',a.max(axis=))
print('a.sum(axis=0)',a.sum(axis=))
print('a.std(axis=0)',a.std(axis=))
print('a.mean(axis=1)',a.mean(axis=1))
print('a.max(axis=1)',a.max(axis=1))
print('a.sum(axis=1)',a.sum(axis=1))
print('a.std(axis=1)',a.std(axis=1))
#np.where函数是三元表达式 x if condition else y的矢量化版本
a=np.array(range(1,6))  #[1 2 3 4 5]
b=np.arange(6,11) #[ 6  7  8  9 10]
print('a=',a)
print('b=',b)
c=np.array([True,True,False,False,True])
result=[(x if c else y) for x,y,c in zip(a,b,c)]
print('result=',result)  #[1, 2, 8, 9, 5]
result=np.where(c,a,b)
print('result=',result) #[[1 2 8 9 5]]
#将数组中所有NaN缺失值替换为0
a=np.array([[1,2,np.NaN,4],[5,6,7,np.NaN]])  #[[ 1.  2. nan  4.] [ 5.  6.  7. nan]]
print('np.isnan(a)=',np.isnan(a))        #[[False False  True False] [False False False  True]]
print('np.where(np.isnan(a),0,a)=',np.where(np.isnan(a),,a)) #[[1. 2. 0. 4.] [5. 6. 7. 0.]]
#np.nunique函数是求数组中不重复的元素
a=np.array(['苹果','橘子','香蕉','橘子','桔子'])
print('a=',a)
print('np.unique(a)=',np.unique(a))   #['桔子' '橘子' '苹果' '香蕉']
for b in np.unique(a):
    print(b)
#数组数据文件读写
#将数组以二进制格式保存到磁盘
a=np.arange(1,13).reshape(3,4)
print('a=',a)
np.save('data',a)
b=np.load('data.npy')
print('b=',b)
#存取文本文件
a=b=c=np.arange(,5,1)
np.savetxt('test1.out',a,delimiter=',')
np.savetxt('test2.out',(a,b,c))
np.savetxt('test3.out',a,fmt='%1.4e')
np.savetxt('test.csv',a,delimiter=',')
d=np.loadtxt('test.csv',delimiter=',')
print('d=',d)
e=np.genfromtxt('test.csv',delimiter=',')
print('e=',e)