python中numpy的基本使用和random的一些函数

基本使用

import numpy as np
#用array构造一维数组
arr1 = np.array([1,2,3,4])
print(arr1)
#用array构造二维数组
arr2=np.array([[2,3,4],[5,6,7]])
print(arr2)
arr2

[1 2 3 4]
[[2 3 4]
[5 6 7]]
array([[2, 3, 4],
[5, 6, 7]])

#用arange构造数组，构造的数组从0开始，个数为括号中的数
arr3=np.arange(5)
print(arr3)
arr4=np.array([np.arange(3),np.arange(3)])
print(arr4)

[0 1 2 3 4]
[[0 1 2]
[0 1 2]]

#reshape改变数组的维度
arr5 = np.arange(24).reshape(2,3,4)
arr5

array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])

np.bool(1)

True

#数组维度的数量
arr2.ndim

2

#数组的形状
arr5.shape

(2, 3, 4)

#数组中元素的数量，也就是shape的结果相乘
arr5.size

24

#数组中每个元素所占字节的大小
arr6=np.array([1.5,2.3,6.5])
arr6.itemsize

8

#数组中元素一共占的字节大小=itemsize*size
arr6.nbytes

24

#数组转置,本体arr4没变
arr7=arr4.T
print(arr7)
print(arr7.transpose())

[[0 0]
[1 1]
[2 2]]
[[0 1 2]
[0 1 2]]

#一维数组的切片
a=np.arange(7)
#从第一个开始取，取4-1=3个
print(a[1:4])
#取第一个，然后隔两个取一个
a[3:7:2]

[1 2 3]
array([3, 5])

#二维数组的切片
b=np.arange(12).reshape(4,3)
print(b)
print(b[0:3,0:2])#前面取列，后面取行

[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
[[0 1]
[3 4]
[6 7]]

import numpy as np
arr8=np.array([0,0,1,1,2,2]).reshape(3,2)
print(arr8)
#把多维数组改变为一维数组
print(arr8.flatten())#复制一份新的，修改不会影响本体
arr8.flatten()[1]=100
print(arr8)
print(arr8.ravel())#返回视图，修改会影响本体
arr8.ravel()[4]=100
print(arr8)

[[0 0]
[1 1]
[2 2]]
[0 0 1 1 2 2]
[[0 0]
[1 1]
[2 2]]
[0 0 1 1 2 2]
[[ 0 0]
[ 1 1]
[100 2]]

#数组转成列表
arr8.tolist()

[[0, 0], [1, 1], [100, 2]]

#数组转成任意格式
print(arr8.astype(float))            #浮点型

[[ 0. 0.]
[ 1. 1.]
[100. 2.]]

#numpy常用统计函数
b=np.array([[ 0, 1, 20, 3, 4, 5],[ 6, 7, 8, 9, 10, 11]])

#求最大值
print(np.max(b))
#求沿axis=1轴方向统计最大值，每一行进行比较
print(np.max(b,axis=1))
#求最小值
print(np.min(b))
#求沿axis=0轴方向统计最小值，每一列进行比较
print(np.min(b,axis=0))

20
[20 11]
0
[0 1 8 3 4 5]

#返回数组中最大值减去最小值
print(np.ptp(b))
#沿axis=0，即每列最大值减去最小值
print(np.ptp(b,axis=0))
#沿axis=1，即每行最大值减去最小值
print(np.ptp(b,axis=1))

20
[ 6 6 12 6 6 6]
[20 5]

b.resize(4,3)
print(b)

[[ 0 1 20]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]

#沿列方向依次累加
print(np.cumsum(b,axis=0))
#沿行方向依次累加
print(np.cumsum(b,axis=1))

[[ 0 1 20]
[ 3 5 25]
[ 9 12 33]
[18 22 44]]
[[ 0 1 21]
[ 3 7 12]
[ 6 13 21]
[ 9 19 30]]

#沿列方向依次累乘
print(np.cumprod(b,axis=0))
#沿行方向依次累乘
print(np.cumprod(b,axis=1))

[[ 0 1 20]
[ 0 4 100]
[ 0 28 800]
[ 0 280 8800]]
[[ 0 0 0]
[ 3 12 60]
[ 6 42 336]
[ 9 90 990]]

#数组的广播，就是数组与标量做运算时，标量改变成数组的格式
print(b)
d=b+2
print(b)

[[ 0 1 20]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
[[ 0 1 20]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]

numpy中random的一些函数

（函数非常少）

import numpy as np
#numpy.random.eand(d0,d1,……,dn)
#rand函数根据给定的维度生成[0,1)之间的数据
#dn表示表格的第n个维度
print(np.random.rand(4,2))#4行2列
print(np.random.rand(4,3,2))#4块3行2列

[[0.49389979 0.81490345]
[0.09817178 0.803256 ]
[0.36264398 0.79849486]
[0.07936067 0.66654057]]
[[[0.22787189 0.339923 ]
[0.67507703 0.75938864]
[0.47181075 0.45562696]]

[[0.9583842 0.64579948]
[0.36533534 0.40048645]
[0.33431584 0.46221737]]

[[0.28649841 0.27141595]
[0.33426126 0.00927193]
[0.23149327 0.22421478]]

[[0.71224952 0.56724126]
[0.78355078 0.8932719 ]
[0.23967193 0.30825069]]]

#numpy.random.randint(low,high=None,size=None,dtype="l")
#返回[low,high)之间的随机整数,size是数组维度，dtype是数据类型，默认为整形
#high没有填写时，默认生成的随机数的范围是[0,low]
print(np.random.randint(1,size=5))#返回[0,1)之间的整数，所以只有0
print(np.random.randint(1,5))
print(np.random.randint(-5,5,size=(2,2)))

[0 0 0 0 0]
1
[[ 1 -5]
[ 0 3]]

#numpy.random.choice(a,size=None,replace=True,p=None)
#从给定的一维数组或者整数中随机生成
#a为一维数组类似数据或整数，size为数组维度，p为数组中数据出现的频率
print(np.random.choice(5,3))
#当replace为False时，生成的随机数不会重复
print(np.random.choice(5,3,replace=False))
ls=['zhangsan','lisi','wangwu','zhaoliu','xiaoming']
print(np.random.choice(ls,size=(3,2)))
#p要满足两点，一是概率相加为1，二是长度和a一致
print(np.random.choice(ls,size=(3,2),p=[0.4,0.2,0.2,0.1,0.1]))

[1 3 4]
[0 4 1]
[[‘wangwu’ ‘wangwu’]
[‘xiaoming’ ‘lisi’]
[‘zhangsan’ ‘lisi’]]
[[‘xiaoming’ ‘lisi’]
[‘zhangsan’ ‘zhangsan’]
[‘wangwu’ ‘lisi’]]