写在前面：
我们都知道数据整理成矩阵的形式，方便处理。
Numpy是一个矩阵运算的数据库，也可以用作其他的用途
'''
Creat by HuangDandan
[email protected]
2018-08-26
'''
import numpy as np
##1-查看某一个函数的用法 print (help(numpy.函数名称))---------------------------------------
#print(help(np.shape))
'''
2-定义一个数组，二维矩阵 像list of list结构，三维矩阵就写三个中括号[]
构造数组＝numpy.array的时候，限制list里面的元素必须是相同的元素。
如果不是的话，numpy.array会将所有的元素转换成更加通用的格式
数组的形状，用来打印变量的总装，查找bug
一维数组返回 (元素个数)二维数组返回(行，列)
'''
Vector = np.array([10,20,30,40])
Matrix = np.array([[10,25],[10,40],[10,25]])
a = np.array([[[1,2],[3,4],[5,6]],[[7,8],[9,10],[11,12]]])
print(Vector.shape,Vector.shape,a.shape)
#3-数组.dtype 得到数组中元素的类型---------------------------------------
print(Vector.dtype)
#4----------------------------------------切片---------------------------------------
#一维数组 0，1，2的元素 matrix[0：3]位数为3的元素取不到
#二维数组 按照行和列取元素，从0开始，：表示左右的元素。一列的数据，matrix［:,1］一行的数据，matrix［1,:］
print(Matrix[0:1]) #第1行数据，第二行取不到，返回二维数组
print(Matrix[:,1]) #一列的数据
print(Matrix[0,:]) #一行的数据
'''
5-对矩阵中所有的元素进行判断，返回布尔类型的元素-----------------------------
vector==0
matrix==0
向量或者矩阵中将布尔类型当做索引，可以输出位置为true的元素值(真实值)例如：向量中取出等于10的元素值
equal_to_10＝(vector==10)
vector[equal_to_10]
矩阵中取出第二列中数值为25的那一行
second_column_25＝(matrix[:,1]==25)
matrix［second_column_25,：］
矩阵中判断同时满足两个条件 与 &
equal_to_10_and_15=(vextor==10&vector ==15) 返回值也为布尔类型
只要满足条件中的一个 或| 判断
'''
Id1 = (Vector == 20)
Id2 = (Matrix == 10) #将布尔类型的矩阵作为索引，可以取出矩阵中的值
print(Id1)
print(Id2) #返回值为布尔类型元素组成的矩阵
print("---------")
print(Vector[Id1].shape)
print(Matrix[Id2].shape)
print(Vector[Id1])
print(Matrix[Id2])
#6-----------------------------------矩阵中取出第二列中数值为25的那一行----------------------------
second_column_25 = (Matrix[:,1]==25)#第二列中等于25的索引
print((Matrix[:,1]==25))
print(Matrix[second_column_25,:])
#7----------------------------------------------矩阵中元素强制转换-------------------------------
Matrix.astype(str)
print(Matrix)
#8----------------------------------------------矩阵中所有行元素相加---------------------------------------
print(Matrix.sum(axis=1))
#矩阵中所有列元素相加
print(Matrix.sum(axis=0))输出：
引用块内容(4,) (4,) (2, 3, 2)
int32
[[10 25]]
[25 40 25]
[10 25]
[False True False False]
[[ True False]
[ True False]
[ True False]]
(1,)
(3,)
[20]
[10 10 10]
[ True False True]
[[10 25]
[10 25]]
[[10 25]
[10 40]
[10 25]]
[35 50 35]
[30 90]
#9---------------------------------------------矩阵变换---------------------------------------
np.arange(15)
np.arange(15).reshape(3,5)
print(np.arange(15))
print(np.arange(15).reshape(3,5))
print(Matrix.size)#元素个数
print(Matrix.dtype.name)#矩阵元素类型
print(Matrix.shape)#矩阵形状 行*列
print(Matrix.ndim)#矩阵维度 列（属性）
print(np.zeros((4,2))) #初始化矩阵
print(np.zeros((2,3,4),dtype=np.int32))
print(np.ones((2,3,4),dtype=np.int32))
#10-----------------------------------------生成随机数组，例如权重模块的初始化---------------------
np.random.random((2,3))
print(np.random.random((2,3)))
#linspace平均取值，起始值和终点值，以及多少值，平均取值
from numpy import pi
np.linspace(0,2*pi,100)
print(np.linspace(0,pi,10))
'''
10---------------------------------------矩阵的代数计算---------------------------------------
两个一维数组相减，对应位置相减，一维数组减去一个值，所有的数值减去0.
元素值平方 A*B对应位置元素相乘
矩阵的乘法(行*列)
A.dot(B)
numpy.dot(A,B)
xp 根号计算 sqrt
根据元素的个数和维数，自动计算剩下的维数matrix.reshape(3,-1)
矩阵的拼接
'''
'''
11-------------------------------乘法---------------------------------------
A*B——对应位置元素相乘
矩阵的乘法(行*列)
A.dot(B)
numpy.dot(A,B)
'''
A = np.array([[1,1],[1,1]])
B = np.array([[1,1],[1,1]])
C = np.array([[2,2],[2,2]])
A.dot(B)
np.dot(A,B)
print(np.dot(A,B))
print(A.dot(B))
print(A*B)
#12---------------------------------------------幂操作 exp 根号计算 sqrt------------------------
np.exp(C)
print(np.exp(C))
np.sqrt(C)
print(np.sqrt(C))
#13---------------------------根据元素的个数和维数，自动计算剩下的维数Matrix,reshape(3,-1)
print(Matrix.reshape(-1)) #1行
print(Matrix.reshape(2,3)) #(2,3)为行*列
print(Matrix.reshape(-1,1)) #1列，自动计算行数
print(Matrix.reshape(-1,2)) #2列，自动计算行数
#14----------------------------------矩阵的切分，平均切分和指定切分--------------------------------
#Matrix = np.array([[10,25],[10,40],[10,25]])
np.hsplit(Matrix,2)
print(np.hsplit(Matrix,2))
print(np.vsplit(Matrix,3))
#15---------------------------------------矩阵的复制---------------------------------------
'''
1 a=b ab指向同一个值
2 c=a.view() 浅复制 a和c不是同一个东西，指向的不同的东西，共用了一堆值。改变c的值可能对a值也有影响
3 d=a.copy() 复制，用a的值给d初始化，之后a和d没有关系，改变a的值对d的值没有影响
'''
#16---------------------------------------矩阵的扩展---------------------------------------
# np.tile(Matrix,(2,3)) #(2,3)为行和列，行变成原来的两倍，列bian成原来的三倍
# print(np.tile(Matrix,(2,3)))
#17---------------------------------------矩阵的排序---------------------------------------
'''
两种排序方式，一种按照行或者列排序，一种利用索引排序
numpy.sort(a,axis=1)
numpy.argsort(a, axis=-1, kind=’quicksort’, order=None)
功能: 将矩阵a按照axis排序，并返回排序后的下标
参数: a:输入矩阵， axis:需要排序的维度
返回值: 输出排序后的下标矩阵
numpy.argsort()最小值到最大值的索引，得到索引可以再传到原来的矩阵中，得到索引对应的真实值
'''
Matrix1 = np.array([[1,32,1],[23,43,12],[11,10,9]])
np.sort(Matrix1,axis=0) #axis=0 列排序
print(np.sort(Matrix1,axis=0))
np.sort(Matrix1,axis=1) #axis=1 行排序
print(np.sort(Matrix1,axis=1))
IndexSort0 = np.argsort(Matrix1,axis=0) #默认按照列排列
IndexSort1 = np.argsort(Matrix1,axis=1) #默认按照行排列
IndexSort = np.argsort(Matrix1) #默认按照行排列
print('------------indexsort----------------')
print(IndexSort0)
print(IndexSort1)
print(IndexSort)
print(Matrix1[IndexSort])
#矩阵的拼接，横着拼接，增加特征数；竖着拼接，增加样本数???
# a = np.array([[1,2],[2,3]])
# b = np.array([[1,2],[1,2]])
# a = [[1,2],[2,3]]
# b = [[1,2],[1,2]]
# np.hstack(a,b) #横
# np.vstack(a,b) #竖
# print(np.hstack(a, b))
# print(np.vstack(a, b))输出：
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
6
int32
(3, 2)
2
[[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]]
[[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]]
[[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]]
[[0.37960182 0.94010155 0.96698014]
[0.94928902 0.33968149 0.87611687]]
[0. 0.34906585 0.6981317 1.04719755 1.3962634 1.74532925
2.0943951 2.44346095 2.7925268 3.14159265]
[[2 2]
[2 2]]
[[2 2]
[2 2]]
[[1 1]
[1 1]]
[[7.3890561 7.3890561]
[7.3890561 7.3890561]]
[[1.41421356 1.41421356]
[1.41421356 1.41421356]]
[10 25 10 40 10 25]
[[10 25 10]
[40 10 25]]
[[10]
[25]
[10]
[40]
[10]
[25]]
[[10 25]
[10 40]
[10 25]]
[array([[10],
[10],
[10]]), array([[25],
[40],
[25]])]
[array([[10, 25]]), array([[10, 40]]), array([[10, 25]])]
[[ 1 10 1]
[11 32 9]
[23 43 12]]
[[ 1 1 32]
[12 23 43]
[ 9 10 11]]
————indexsort—————-
[[0 2 0]
[2 0 2]
[1 1 1]]
[[0 2 1]
[2 0 1]
[2 1 0]]
[[0 2 1]
[2 0 1]
[2 1 0]]
[[[ 1 32 1]
[11 10 9]
[23 43 12]]
[[11 10 9]
[ 1 32 1]
[23 43 12]]
[[11 10 9]
[23 43 12]
[ 1 32 1]]]
温故：
1- axis=0 axis=1的理解
axis=0代表往跨行（down)，而axis=1代表跨列（across)，作为方法动作的副词
axis=0代表往跨行（down)，按列操作， 使用0值表示沿着每一列或行标签\索引值向下执行方法
axis=1代表跨列（across)，按行操作， 使用1值表示沿着每一行或者列标签模向执行对应的方法
轴用来为超过一维的数组定义的属性，二维数据拥有两个轴：第0轴沿着行的垂直往下，第1轴沿着列的方向水平延伸。
2-range() xrange() randrange()
python
range([start], stop[, step])
返回等差数列。构建等差数列，起点是start，终点是stop，但不包含stop，公差是step。start 和 step 是可选项，没给出start时，从0开始；没给出step时，默认公差为1。
xrange([start], stop[, step])
xrange与range类似，只是返回的是一个“xrange object”对象，而非数组list。要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间
random.randrange([start], stop[, step])返回的是一个随机数，这个随机数来源于 range([start], stop[, step]) 。
python3
python3 取消了 xrange() 函数，并且和 range() 函数合并为 range()。
import sys
import random
a = range(1,11,2)
c = random.randrange(1,11,2)
print(sys.version)
print(a)
print(type(range(10)))输出：
3.6.5 |Anaconda, Inc.| (default, Mar 29 2018, 13:32:41) [MSC v.1900 64 bit (AMD64)]
range(1, 11, 2)