整理numpy

• 整理numpy
  这里写自定义目录标题
  • 目录
  • • 导入numpy包
    • 创建
    • • 使用列表/元组创建
      • 快速创建-使用固定格式
      • • np.ones()/np.zeros()/np.eye()/np.empty()/np.arange()/np.empty()/np.random.random()
        • 其他
    • 属性
    • • shapesizendim
      • dtype
      • 二维矩阵完成转置 T
    • 方法
    • • reshape
      • astype
      • transpose
    • 广播机制：广播机制：为了解决两个数组进行对应元素操作，但是形状不同的问题
    • • 广播规则
      • 快速判断能够否广播
    • 索引和切片
    • • 基本轴访问
      • 数组索引
      • 剩余轴的索引
      • 布尔数组索引
    • 元素修改
    • • 索引修改
      • 关于内存修改还是拷贝复制
    • 运算
    • • 矩阵乘法
      • 对应元素相乘

目录

对近期所学的numpy基础的整理

导入numpy包

import numpy as np

创建 使用列表/元组创建

lis = [1,2,3]
lis2 = [[1,2,3],[1,2,3]]
arr1 = np.array(lis)    #默认dtype np.int32
arr2 = np.array(lis2,dtype=np.float)  #指定元素的数据类型

快速创建-使用固定格式 np.ones()/np.zeros()/np.eye()/np.empty()/np.arange()/np.empty()/np.random.random()

arr1 = np.ones((3,3))  #全1
arr2 = np.zeros((3,3)) #全0
arr3 = np.eye(3)   #主对角线为1
arr4 = np.arange(1,9).reshape(2,4)  #arange创建出来的是一维的，一般配合reshape使用
arr5 = np.random.random((3,2,3))  # 也是随机的，和empty有什么区别不太知道

其他

print(np.logspace(0,2,5))   # 在1e0-1e2产生5个数 

np.logspace(0,2,5)   #1e0-1e2 产生5个数 

属性 shapesizendim

print(arr1.shape)  # 形状。元组，元组的元素个数代表数组的维数，元素数值的大小代表该维度数组的个数。
print(arr1.size)	# 一共有多少个元素，等于shape所有元素的乘积，也就是shape数字的累乘
print(arr1.ndim)	# 数组的维数 = len(arr1.shape)

dtype

print(arr1.dtype)	# 元素的类型。numpy中所有的元素类型都是一样的  np.int8,np.int32,np.float...

二维矩阵完成转置 T

arr1_T = arr1.T  # 二维的直接使用.T属性完成转置  transpose(arr1,[1,0])。等同于np.transpose(arr1,[-1,1,0])

方法 reshape

arr3 = arr2.reshape((3,2)) 	# 参数是tuple类型的，单个int也可以，但是要保证元组元素的个数是一样的
arr4 = arr2.reshape((3,2,-1))	# -1在满足其他确定条件后自动计算该轴的元素个数。只能有一个-1.

astype

arr5 = np.array([int('0b10000000',base=2)])
print(arr5.dtype)
arr5 =arr5.astype('int8')  # np.int8只能保存-128-127之间的数字
print(arr5.dtype)

transpose

arr1 = np.arange(18).reshape(3,3,2)
print('arr1:n',arr1)
print()
arr1_t = np.transpose(arr1,[1,2,0])  # [1,2,0]为轴的索引 3,3,2 -> 3,2,3
print('arr1_t:n',arr1_t)
print()

广播机制：广播机制：为了解决两个数组进行对应元素操作，但是形状不同的问题 广播规则

#(2,3) (3,)
# 1.维度不同时，最高维输出的最终维度,所以是2维
# 2.扩充维度。不够最终维度的数组，要补维度，往前面补维度 (3,)->(1,3)
# 3.复制。同维度的元素个数，要么相同，要么其中一个为1.哪个维度为1，复制哪个维度。(3,)->(1,3)->(2,3)

快速判断能够否广播

#1.看形状：从右往左看只需要看最短的
#2.对应位置的元素要么相同，要么其中一个为1
#3.广播操作的时候，从左往右

索引和切片 基本轴访问

np.random.seed(0)
arr6 = np.random.random((3,3))
print('arr6n',arr6)
print()
print(arr6[0],'n')     #操作0轴的第一个
print(arr6[1],'n')     #操作0轴的第二个
print(arr6[1:],'n')    #切片，索引0轴的第二个-第三个
print(arr6[::-1],'n')  #操作0轴,倒着取
print(arr6[:,1:],'n')  #先0轴后1轴
print(arr6[0][1:],'n') #操作0轴的第一个，索引1-2
#如果要判断维数的，记住索引降维，切片不降维

数组索引

arr7 = np.arange(9).reshape((3,-1))
print('arr7n',arr7)
print()
print(arr7[[1,0,2]])  #取第0轴的第2个元素+第1个元素+第3个元素
print()
print(arr7[[0,1,2],[0,1,2]])  #(0,0) (1,1) (2,2)取了对角线，和坐标有点像
print()
print(arr7[[0,1,2],0])  #0不够会进行广播
print()
print(arr7[0,[0,1,2]])  #0不够会进行广播
print()
#print(arr7[[1,2],[0,1,2]])  #报错
print()
print(arr7[:,[0]])#切片+数组(0,0)(1,0)(2,0)
print(arr7[:,0])   #这里要注意一下维度，索引会降维

剩余轴的索引

不会降维

arr1 = np.arange(18).reshape(3,3,2)
print("arr1:n",arr1)
print()
print("arr1:n",arr1[:,:,0])
print()
print("arr1:n",arr1[...,0])    #等同于arr1[:,:,0]
print()

布尔数组索引

不会降维
对应位置为True的被成功索引

arr2 = np.arange(9)
cd = arr2<3
print("arr2:n",arr2)
print()
print("arr2:n",cd)   #有点像filter
print()
print("arr2[cd]:n",arr2[cd])   #有点像filter
print()
print("arr2[arr2<3]:n",arr2[arr2<3])   #有点像filter
print()

元素修改 索引修改

arr3 = np.zeros((3,3))
print("arr3:n",arr3)  
print()
arr3[0][0]=3.
print("arr3:n",arr3)   
print()
arr3[0]=4.   #有广播在里面的
print("arr3:n",arr3)   
print()
arr3[...]=1.   #有广播在里面的    == arr3[:,:]=1. 
print("arr3:n",arr3)   
print()
# 全元素修改
arr4 = np.arange(9).reshape(3,3)
arr3[...] = arr4   #发现没有，数据类型改了，arr3原来存放浮点型，现在复制过去也变成浮点型了
print('arr4:n',arr4)
print('arr3:n',arr3)
# 全元素广播
arr3[...] = 10   #发现没有，数据类型改了，arr3原来存放浮点型，现在复制过去也变成浮点型了
print('arr3:n',arr3)
arr3[...] = [1,2,3]   #发现没有，数据类型改了，arr3原来存放浮点型，现在复制过去也变成浮点型了
print('arr3:n',arr3)

关于内存修改还是拷贝复制

arr = np.arange(10,dtype=np.int)
print(arr)
arr[1] = 1.  #修改，类型不会变还是和原来的一样
print(arr)
#修改之前的
print(id(arr))
# way1
arr[...]=3   #直接在原来的内存上修改
print(id(arr))
# way1
arr=np.array([1,2,3])  #重新指向了另一块地址
print(id(arr))

运算 矩阵乘法

arr1 = np.arange(8).reshape(4,2)
arr2 = arr1.T   #这个T是属性
res0 = arr1.dot(arr2)
res1 = arr1 @ arr2
print(res0)
print()
print(res1)

大于二维的以最后两个维度为元素进行相乘

arr1 = np.arange(16).reshape(2,4,2)
arr2 = np.arange(16).reshape(2,2,4)
res0 = arr1.dot(arr2)
res1 = arr1 @ arr2
print(res0)
print()
print(res1)

对应元素相乘

#res2 = arr1 * arr3# 对应元素相乘 不同形状会触发广播，如果不能广播就会报错
#res4 = np.multiply(arr1, arr3)