数组索引 笔记2

数组的类型及形状
numpy里面的数据类型
 numpy里面的数据类型，其实就是封装了python里面的基础的数据类型，然后还进行细致划分，之后封装为np.数据类型
 1，创建数组的时候通过dtype属性来指定 元素的数据类型
 arr=np.array([1,2,3,4]),dtype=float32()
 2，也可以进行强制转换
 res=np.float32(5)
 3，可以通过stype来修改数据类型
 将arr的float32类型转化为int32类型
 arr=arr.astype(np.int32)
 arr.dtype=np.int32-->转化类型正确，但是元素发生变化，不建议用
 
 4，ndarray也可以存储复合数据类型--了解
 存储人对象--人对象 3个属性--姓名，身高，体重
 df=np.dtype([('name',np.str,40),('high',np.float32),('weight',np.float32)])
 
 #创建一个存储复合数据的数组对象
 arr=np.arrpy([('bq',168.5,50.5),('yf',172,55),dtype=df])--一般不用，后面有专门的结构去存储复合类型
 
 #形状--shape
 arr=np.arange(16)#--0到15的一维数组
 print(arr)
 print('arr的形状:\n',arr.shape)
 #arr的形状(16,)
 
 #修改形状 --元素的总个数必须一致
 #1，通过shape 属性进行修改
 arr.shape=(4,4)
 print(arr)
 print('arr的形状:\n',arr.shape)
 #2，通过reshape来修改数组的形状
 #reshape 会返回一个新的数组，需要去接收
 arr=arr.reshape((4,4))
 print(arr)
 print('arr的形状:\n',arr.shape)
 
 数组的索引
 import numpy as np
 
 #创建一个一维数组
 arr=np.arange(1,10)
 print(arr)
 
 #使用单独的下标 会造成降低维度
 #获取 arr里面的6 这个元素--下标
 print('获取arr里面的6:',arr[5])#--0维
 #获取 arr里面的9 这个元素--下标
 print('获取arr里面的9:',arr[-1])
 #获取arr里面的6和9 --下标列表--没降维
 print('获取arr里面的6和9:\n',arr[5,-1])#--1维
 #运行结果 [6,9]
 
 #获取arr 里面的6 这个元素 --切片--没降维
 print('获取arr里面的6:\n,arr[5:6])
 #获取arr里面的9 这个元素 --切片
 print('获取arr里面的9:\n,arr[-1:]
 #获取arr里面的6和9着两个元素--切片
 print('获取arr里面的6和9:\n',arr[5::3])
 
 #创建一个二维数组 从第0行开始
 arr=np.arange(1,17).reshape(4,4))
 print(arr)
 
 #使用单独的下标 会进行降低维度
 #使用切片不降低维度
 #使用下标列表--可以理解为 将多个下标的值取出来，然后组合起来--一维
 
 #获取arr里面的 6这个元素
 print('获取arr里面的6:\n',arr[1,1]
 #获取arr里面的11这个元素
 print('获取arr里面的11:\n',arr[2,2]
 
 #获取arr里面的6和11 这两个元素 #--下标列表 
 #找的 行列上--对应位置的元素
 print('获取arr里面的6和11 这两个元素:\n',arr[[1,2],[1,2]])
 
 #获取arr里面的8和15 这两个元素--下标列表
 print('获取arr里面的8和15 这两个元素:\n',arr[[1,3],[3,2]])
 
 #获取arr里面的6 这个元素--切片
 print('获取arr里面的6--切片--二维 这个元素:\n',arr[1:2,1:2])
 #获取arr里面的11这个元素--切片
 print('获取arr里面的11这个元素:\n',arr[2:3,2:3])
 
 #获取arr里面的6和11 这两个元素 --下标列表
 print('获取arr里面的6和7 ，10和11:\n',arr[[1,2],1:3])#获取的 一块元素
 
 #获取11 12 15 16这四个元素
 print('获取 11 12 15 16这四个元素:\n',arr[2:,2:])
 
 #使用下标列表 --获取11 12 15 16这四个元素
 print('获取11 12 15 16这四个元素:\n',arr[[2,2,3,3],[2,3,2,3]])
 
 #获取4 8 12 16 这一列
 print('获取4 8 12 16 这一列:\n',arr[:,3:])
 print('获取4 8 12 16 这一列:\n',arr[:,3])
 
 #三维数组 --arr[块,行,列]
 #n维数组 ---arr[n-1个逗号]将n个维度划分开来，然后在对应的维度进行索引
 
 #bool 数组索引
 #创建一个bool数组
 bool_index=np.array([0,1,1,0],dtype=np.bool)
 print('bool_index:\n',bool_index)
 
 # 利用bool数组进行 索引 arr #--如果为True 就选中，如果为Flase就干掉
 #bool数组长度必须和 你要索引的维度的数量必须相等
 print(arr[bool_index,:])
 print(arr[:,bool_index])
 print(arr[bool_index,bool_index])#参考前后都是下标列表理解
 
03数组的展开
 
#创建一个二维数组
np.arange(1,17).reshape((4,4))
print(arr)
 
#将二维转为一维
arr=arr.reshape((16,))
 
arr.shape=(16,)

#数组的展开 flatten默认（C风格 行优先） （F风格 列优先）
#flatten --ravel --功能没有区别
#都可以按C风格和F风格
# flatten ---返回一个拷贝的内存
# ravel ----返回原来的引用或者视图

arr=arr.flatten('F')
print(arr)

arr=arr.ravel('C')#--按行展开
arr=arr.ravel('F')#--按列展开
print(arr)

04-数组的合并与拆分
  
 方向的理解
  行：行增大的方向 --垂直方向
  列：列增大的方向--水平方向
  
  #创建两个二维数组
  arr1=np.array([[9,0],[8,9]])
  arr2=np.arange(4),reshape((2,2))
  print('arr1:\n',arr1)
  #[[9 0]
  #[8 9]]
  print('arr2:\n',arr2)
  #[[0 1]
  #[2 3]]
  
  #将arr2 拼接到arr1下边 vstack--垂直的
  res=np.vstack(arr1,arr2)
  print(res)
  
  #将arr2拼接到arr1右边  hstack--水平的
  res=np.hstack(arr1,arr2)
  
  # axis-->指定拼接的轴 axis=0-->行的方向 axis=1-->列的方向
  res=np.concatenate((arr1,arr2),axis=0)
  res=np.concatenate((arr1,arr2),axis=1)
  print(res)
  
  #创建一个数组
  arr=np.arange(1,17).reshape(4,4)
  print(arr)
  
  #拆分的时候，必须能整除,必须平均拆分
  #拆分
  #水平拆分--把 横着的列 打断
  res=np.hsplit(arr,2)
  print('res:\n',res)
  
  #垂直拆分--把竖着的行 打断
  res=np.vsplit(arr,2)
  print('res:\n',res)
  
  # 在行的方向拆分
  res=np.split(arr,2，axis=0)
  # 在列的方向拆分
  res=np.split(arr,2，axis=1)
  
  # 拆分为 三部分[:1],[1:3],[3:]
  np.split(arr,[1,3],axis=0)
  
  #将数组拆分 第一列一部分，其他的列为1部分
  res1=arr[:,:1]
  res2=arr[:,:1:]
  print('res1:\n',res1)
  print('res2:\n',res2)
  
  05矩阵的创建
  
  #创建矩阵--矩阵是二维，也只能是二维的
  #mat 可以将特殊字符串、列表嵌套、二维数组转化为矩阵
  m1=np.mat('1 2 3; 4 5 6;7 8 9')
  m1=np.mat([[1,2],[3,4]])
  m1=np.max(np.array([[1,2],[3,4]]))
  print('m1:\n',m1)
  print('m1的类型:\n',type(m1)) #class numpy.matrixlib.defmatrix.matrix
  print('m1的维度:\n',m1.ndim)
  print(m1[0,:])#矩阵里面使用下标不降低维度
  
  #使用matrix创建矩阵
  m1=np.matrix('1 2 3; 4 5 6;7 8 9')
  m1=np.matrix([[1,2],[3,4]])
  m1=np.matrix(np.array([[1,2],[3,4]]))
  print('m1:\n',m1)
  print('m1的类型:\n',type(m1)) #class numpy.matrixlib.defmatrix.matrix
  print('m1的维度:\n',m1.ndim)
  
  max与matrix的区别
  #mat与asmatrix一样，与matrix 相比少了一个拷贝的过程 --推荐

  #使用bmat来合成矩阵
  #bmat 可以直接将二维数组转化为矩阵
  np.bmat(np.array([[1,2],[3,4]]))
  print('m1:\n',m1)
  print('m1的类型:\n',type(m1))
  
  #创建两个矩阵
  m1=np.mat(np.array([[1,2],[2,1]]))
  m2=np.mat(np.arange(4),reshape((2,2)))
  print('m1:\n',m1)
  print('m2:\n',m2)
  
  #使用矩阵来组合矩阵
  #也可以使用数组来组合矩阵
  m=np.bmat('m1 m2;m2 m1')
  m=np.bmat([[m1,m2],[m2,m1]])
  print('m:\n',m)
  
  #06-矩阵的运算及属性
  
  #创建两个矩阵
  m1=np.mat(np.array([[1,3],[4.5]]))
  m2=np.mat(np.array([[1,2],[1.3]]))
  print('m1:\n',m1)
  print('m2:\n',m2)
  
  #矩阵 与数的相乘 --矩阵的每一个元素与数进行相乘
  m3=m1*2
  print('m3:\n',m3)
  print('m3的类型:\n',type(m3))
  
  #矩阵与矩阵的相加减--对应位置的元素的相加减--必须是同型矩阵
  m3=m1+m2
  print('m3:\n',m3)
  print('m3的类型:\n',type(m3))
  
  #矩阵的相乘 matmul dot --规则：左矩阵的列数必须等于右矩阵的行数，才能进行相乘，返回一个左矩阵行数，右矩阵列数的矩阵
  #m1---(2,2)
  #m2---(2,2)
  #m3---(2,2)
  m3=m1*m2
  np.matmul(m1,m2) 
  np.dot(m1,m2) 
  print('m3:\n',m3)
  print('m3的类型:\n',type(m3))
  
  #同型矩阵对应位置元素的相乘 multiply
  m3=np.multiply(m1,m2)
  print('m3:\n',m3)
  print('m3的类型:\n',type(m3))
  
  #获取矩阵的属性
  print('m1的转置为：\n',m1.T)
  print('m1的共轭转置为：\n',m1.H)
  #可以通过np.mat 将数组转化为矩阵，也可以通过m1.A将矩阵转化为数组
  print('m1的视图为：\n',m1.A)
  print('m1的视图的类型为：\n',type(m1.A)) #--<class numpy.ndarray>
  print('m1的逆矩阵为：\n',m1.I)
  print('m1的逆的值为：\n',np.matmul(m1,m1.I))
  复数-->a+bi,i^2=-1
  a叫做实部 bi叫做虚部
  共轭转置--先共轭，再转置
  实数的共轭就是其本身
  虚数的共轭是其相反数
  
  #07-数组的全通用函数 import numpy as np
  数组的全通用函数--对数组的每一个元素都进行操作的函数 --数据的形状必须数一样的
  
  #创建两个数组
  arr1=np.array([[2,1],[5,6]])
  arr2=np.array([[0,1],[1,0]])
  print('arr1:\n',arr1)
  print('arr2:\n',arr2)
  
  #数组的四则运算 --- + - * / ** --对应位置进行运算
  print('数组相加:\n',arr1+arr2)# 对应位置元素进行相加
  print('数组相减:\n',arr1-arr2)# 对应位置元素进行相减
  print('数组相乘:\n',arr1*arr2)# 对应位置元素进行相乘
  print('数组相除:\n',arr1/arr2)# 对应位置元素进行相除 注意：分母不能为0
  print('数组相幂:\n',arr1**arr2)# 对应位置元素进行求幂
  
  #数组的比较运算 < > <= >= == != --对应位置元素进行相比，如果满足条件，返回T，如果不满足条件，返回F，最终组合返回bool数组
  #返回bool数组
  print('arr1>arr2:\n',arr1>arr2)
  print('arr1!=arr2:\n',arr1!=arr2)
  print('arr1>=arr2:\n',arr1>=arr2)
  print('arr1==arr2:\n',arr1==arr2)
  print('arr1<arr2:\n',arr1<arr2)
  print('arr1<=arr2:\n',arr1<=arr2)
  
  #数组的逻辑运算 --np.any ap.all --返回bool值
  #ap.all 相当于and 只有所有条件都满足，才返回True
  print(np.all(arr1>=arr2))
  print(np.all(arr1>arr2))
  #np.any 相当于or，只要有一个满足条件，就返回True
  print(np.any(arr1==arr2))
  print(np.any(arr1<arr2))
  
  #08-数组的广播机制 import numpy as np
  广播机制--不同形状之间的数组进行算术需要满足的规则
   ufunc函数的广播机制 广播（broadcasting）是指不同形状的数组之间执行算术运算的方式。需要遵循4个原则。 Ø 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐。 Ø 输出数组的shape是输入数组shape的各个轴上的最大值。 Ø 如果各个输入数组的对应轴的长度相同或者其长度为1时，这样的数组之间能够用来计算，否则 出错。 Ø 当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值。
  
  #创建两个不同形状的数组
  arr1=np.array([[1,2],[2,1]])#shape--(2,2)
  arr1=np.array([3,4])#shape --(2,)--(1,2)
  print('arr1:\n',arr1)
  print('arr2:\n',arr2)
  
  #arr1+arr2 
  print('arr1+arr2:\n',arr1+arr2)
  
  #arr1+arr3 ---不可以--不满足 规则3
  print(arr1+arr3) #cuowu
  
  print(arr1+arr4)
  
  #arr1 -->shape(1,2,3,4,5,5,6,7)
  arr2 -->shape(4,1,5,6,1)-->(1,1,1,4,1,5,6,1) 可以进行运算
  
  #arr1-->shape(4,1,2,5)
  #arr2-->shape(2,5,1)--(1,2,5,1)#不可以进行运算
  
  #09-数组的保存与读取
  
import numpy as np

# 二进制形式保存
# 创建数组
arr = np.arange(16).reshape((4, 4))
print("arr:\n", arr)
# arr1 = np.array([1, 2, 3, 4, 5])
# print("arr1 :\n", arr1)
# 保存起来---以二进制形式
# 参数1 --保存的路径+ 名称，后缀名可以省略，默认保存为.npy文件
# 参数2 ---需要保存的数组
# 以二进制保存单个数组
# np.save("./arr",arr)
# print("保存完毕")
# 加载保存的单个数组
# 参数 路径+名称，此时，后缀名不能省略
# res = np.load("./arr.npy")
# print(res)

# 以二进制的形式保存多个数组
# 参数1 路径+名称，此时，后缀名可以省略，默认保存为.npz为结尾的文件
# 接下来的参数 ---需要保存数组
# np.savez("./arr", arr, arr1)
# print("保存完毕")


# 保存的时候以键值对的形式的进行保存的
# 加载.npz文件
# res = np.load("./arr.npz")
# print("res:\n",res)

# for tmp in res:
#     print(tmp)
# 根据键值 取保存的数组
# a = res["arr_0"]
# b = res["arr_1"]
# print("a:\n",a)
# print("b:\n",b)


# 也可以指定 保存的key 来进行保存数组
# 指定key 进行保存
# np.savez("./arr_key", k1=arr, k2=arr1)
# print("保存完毕")

# 加载arr_key.npz文件
# res = np.load("./arr_key.npz")
# for tmp in res:
#     print(tmp)
# k1 = res["k1"]
# k2 = res['k2']
# print("k1:\n",k1)
# print("k2:\n",k2)



# 文本形式保存
# 参数1 保存路径+名称
# 参数2 需要保存的数组
# fmt 保存的格式
# delimiter --分隔符
# np.savetxt("./arr.txt",arr, fmt='%d',delimiter=",")
# print("保存完毕")

# 加载文本类型的数组
# res = np.loadtxt("./arr.txt",dtype=int,delimiter=",")
# print("res:\n",res)

# 可以读取含有缺失值的数组，默认会补上一个与数组不同的值
# res = np.genfromtxt("./arr.txt",dtype=int,delimiter=",")
# print("res:\n",res)

#10-数据的排序
import numpy as np

#创建一个一维数组
arr=np.array([5,7,2,1,0])
arr=np.array([[2,1,0],[5,0,1],[0,2,-1]])
print(arr)
#直接排序 --sort--对原数组直接进行排序
arr.sort(axis=1)
arr.sort(axis=0)
print('arr的排序之后的结果:\n',arr)

#间接排序
#argsort --返回排序之后结果所对应的元素在原来位置的下标
#res=np.argsort(arr,axis=0)
print('res:\n',res)

#lexsort --借助别人的规则，来给自己排序
a=np.array([3,2,6,4,5])
b=np.array([50,30,40,20,10])
c=np.array([400,300,600,100,200])

#按照最后一个元素的规则进行排序，返回最后一个元素，排序之后，结果所对应的元素，原来的下标
res=np.lexsort([a,b,c],axis=0)
res=np.lexsort([a,c,b],axis=0)
res=np.lexsort([b,c,a],axis=0)
print(res)

b_sorted=[b[i] for i in res]
print('b_sorted:\n',b_sorted)