numpy

1 np.array自定义数据结构

itemz = np.array([("tomatoes", 42, 4.14),("cabbages", 13, 1.72)],dtype=df)
print('自定义数据为：',itemz)

2 np.random生成各种随机数

print('生成的随机数组为：',np.random.random(100))
print('生成的服从均匀分布的随机数组为：\n',np.random.rand(10,5))
print('生成的服从正态分布随机数组为：\n',np.random.randn(10,5))
print('生成的给定上下限范围随机数组为：',np.random.randint(2,10,size = [2,5]))


#random常用的随机生成函数：
np.random.seed(0)		#随机数种子
print(np.random.permutation(9))#生成0< <9的的随机数
print(np.random.uniform(0, 10, (3, 4)))#uniform(low, high, size) 产生均匀分布的数组，起始值为low，high为结束值，size为形状
print( np.random.normal(10, 5, (3, 4)))# normal(loc, scale, size)产生正态分布的数组， loc为均值，scale为标准差，size为形状
print(np.random.poisson(0.3, (3,4))) #poisson(lam, size)产生泊松分布的数组， lam随机事件发生概率，size为形状
print(np.random.beta(2,8,(3,4)))#bete分布的随机数
print(np.random.chisquare(0.5,(3,4)))#卡方分布随机数

3 numpy索引

arr[2:4] = 100,101#下标还可以用来修改元素的值
print('索引结果为：',arr[1:-1:2])#范围中的第三个参数表示步长，2表示隔一个元素取一个元素
print('索引结果为：',arr[5:1:-2])  #步长为负数时，开始下标必须大于结束下标

arr = np.array([[1, 2, 3, 4, 5],[4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print('索引结果为：',arr[[(0,1,2),(1,2,3)]])
#从两个序列的对应x,y下位置取出两个整数组成下标：arr[0,1], arr[1,2], arr[2,3]
print('索引结果为：',arr[1:,(0,2,3)])  #索引第2、3行中第0、2、3列的元素
mask = np.array([1,0,1],dtype = np.bool)#mask是一个布尔数组，它索引第1、3行中第2列的元素
print('索引结果为：',arr[mask,2])

4 numpy ravel flatten concatenate·展平组合和分割

arr = np.arange(12).reshape(3,4)
print('数组维度为：',arr.reshape(3,4).ndim)  #查看数组维度
print('数组展平后为：',arr.ravel())
print('数组展平为：',arr.flatten())  #横向展平
print('数组展平为：',arr.flatten('F'))  #纵向展平

arr1 = np.arange(12).reshape(3,4)
arr2 = arr1*3
print('横向组合为：',np.hstack((arr1,arr2)))  #hstack函数横向组合
print('纵向组合为：',np.vstack((arr1,arr2)))  #vstack函数纵向组合
print('横向组合为：',np.concatenate((arr1,arr2),axis = 1))  #concatenate函数横向组合
print('纵向组合为：',np.concatenate((arr1,arr2),axis = 0))  #concatenate函数纵向组合
arr = np.arange(16).reshape(4,4)
print('创建的二维数组为：',arr)
print('横向分割为：',np.hsplit(arr, 2))  #hsplit函数横向分割
print('纵向分割为：',np.vsplit(arr, 2))  #vsplit函数纵向分割
print('横向分割为：',np.split(arr, 2, axis=1))  #split函数横向分割
print('纵向分割为：',np.split(arr, 2, axis=0))  #split函数纵向分割

5 numpy mat矩阵的操作

matr1 = np.mat("1 2 3;4 5 6;7 8 9") #使用分号隔开数据
matr2 = np.matrix([[123],[456],[789]])
arr1 = np.eye(3)
arr2 = 3*arr1
print('创建的矩阵为：',np.bmat("arr1 arr2; arr1 arr2"))

matr1 = np.mat("1 2 3;4 5 6;7 8 9")  #创建矩阵
matr2 = matr1*3  #矩阵与数相乘
print('矩阵相加结果为：',matr1+matr2)  #矩阵相加
print('矩阵相减结果为：',matr1-matr2)  #矩阵相减
print('矩阵相乘结果为：',matr1*matr2)  #矩阵相乘
print('矩阵对应元素相乘结果为：',np.multiply(matr1,matr2))
print('矩阵转置结果为：',matr1.T)  #转置
print('矩阵共轭转置结果为：',matr1.H)  #共轭转置（实数的共轭就是其本身）
# print('矩阵的逆矩阵结果为：',matr1.I)  #逆矩阵,矩阵 A 为奇异矩阵，不可逆的时候将报错
print('矩阵的二维数组结果为：',matr1.A)  #返回二维数组的视图

6 numpy sort排序

arr = np.random.randint(1,10,size = 10)  #生成随机数
arr.sort()  #直接排序
arr.sort(axis = 1)  #沿着横轴排序
arr.sort(axis = 0)  #沿着纵轴排序
print('排序后数dd组为：',arr.argsort())  #返回值为重新排序值的下标

a = np.array([3,2,6,4,5])
b = np.array([50,30,40,20,10])
c = np.array([400,300,600,100,200])
d = np.lexsort((a,b,c))  #lexsort函数只接受一个参数，即（a,b,c）
print('排序后数组为：',list(zip(a[d],b[d],c[d])))#多个键值排序是按照最后一个传入数据计算的

6 numpy 和，均值，标准差，方差，最大/小值，最值元素的索引

arr = np.arange(20).reshape(4,5)
print('数组的和为：',np.sum(arr))  #计算数组的和
print('数组横轴的和为：',arr.sum(axis = 0))  #沿着横轴计算求和
print('数组纵轴的和为：',arr.sum(axis = 1))  #沿着纵轴计算求和
print('数组的均值为：',np.mean(arr))  #计算数组均值
print('数组横轴的均值为：',arr.mean(axis = 0))  #沿着横轴计算数组均值
print('数组纵轴的均值为：',arr.mean(axis = 1))  #沿着纵轴计算数组均值
print('数组的标准差为：',np.std(arr))  #计算数组标准差
print('数组的方差为：',np.var(arr))  #计算数组方差
print('数组的最小值为：',np.min(arr))  #计算数组最小值
print('数组的最大值为：',np.max(arr))  #计算数组最大值
print('数组的最小元素为：',np.argmin(arr))  #返回数组最小元素的索引
print('数组的最大元素为：',np.argmax(arr))  #返回数组最大元素的索引
arr = np.arange(2,10)
print('数组元素的累计和为：',np.cumsum(arr))  #计算所有元素的累计和
print('数组元素的累计积为：',np.cumprod(arr))  #计算所有元素的累计积

7 高级表达积累

高级数组索引：必须是数组形式，list是不行的，还有，必须保证，a, b的长度一样。

import numpy as np
a = np.array([0, 0, 0, 0, 1, 1, 1, 1, 1])
b = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
print(b[a == 0])

输出结果为：[1 2 3 4]

shuffle
import numpy as np
data = np.array([0,1,2,3,4,5,6,7,8,9]) # 必须是数组
shuffle_index = np.random.permutation(len(data)) # 得到随机索引
shuffle_data = data[shuffle_index] # 得到shuffle后的打他

==np.full ==

import numpy as np
 
# 构造一个2x3的数组，其中元素全部都为 7
ndarray = np.full((2, 3), 2)
print(ndarray)
"""
[[2 2 2]
 [2 2 2]]


np.full((2, 2), [1, 2])
输出为： array([[1, 2],
               [1, 2]])