numpy中的操作（一）

一、 numpy简介

1、numpy是用于科学计算基础的模块，主要被用作高效的多维储存容器，可以用来储存容器，可以用来储存和处理大型的矩阵。
2、numpy 提供了两种基本的对象：ndarray（数组，表示储存单一的数据类型的多维数据），ufunc（能够对数组进行运算的函数）

二、numpy应用

1.数组创建和基本属性

（1）利用numpy创建数组（np.array（[],[]））

①创建一维数组

arr=np.array([1,2,3,4])
print(arr)
#[1 2 3 4]

②创建二维数组

arr2=np.array([[1,2,3],[4,5,6]])
print(arr2)
#[[1 2 3]
#[4 5 6]]

（2）常用的数组的属性

①数组的结构（数组.shape）

print('数组的结构:',arr2.shape)
#数组的结构: (2, 3)

②数组的类型（数组.dtype）

print('元素的类型:',arr2.dtype)
#元素的类型: int32

③元素的个数（数组.size）

print('元素的个数:',arr2.size)
#元素的个数: 6

④数组的维度（数组.ndim）

print('数组的维度:',arr2.ndim)
#数组的维度: 2

⑤重设数组的形状（数组.shape=行,列）

arr2.shape=3,2
print(arr2)
#[[1 2]
#[3 4]
#[5 6]]

2.numpy中专门构造数组的函数

（1）np.arange(起始值，终止值，步距)，类似于python中的range（左闭右开）

print(np.arange(0,1,0.1))
#[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]

（2）np.linspace(起始值，终止值，个数)，构造一个等差数列 ，封闭区间

print(np.linspace(0,1,12))
#[ 0.          0.09090909  0.18181818  0.27272727  0.36363636  0.45454545
  0.54545455  0.63636364  0.72727273  0.81818182  0.90909091  1.        ]
 

（3）np.logspace（起始值，终止值，个数，基数）构造一个等比数列

print(np.logspace(0,2,10,base=2.0))##基数是2  起始值是2的0次方 终止值是2的2次方 共10个值,base默认为10，想要其他的值可以自行修改
#[ 1.          1.16652904  1.36079     1.58740105  1.85174942  2.16011948
  2.5198421   2.93946898  3.42897593  4.        ]

（4）np.zeros（（行，列）），全零数组

print(np.zeros((2,3)))
#[[ 0.  0.  0.]
# [ 0.  0.  0.]]

（5）print(np.eye(n))，对角单位数组

print(np.eye(3))
#[[ 1.  0.  0.]
# [ 0.  1.  0.]
# [ 0.  0.  1.]]

（6）np.diag（），对角阵

print(np.diag([1,2,3]))
#[[1 0 0]
# [0 2 0]
# [0 0 3]]

（7）np.ones（（行，列）），全一矩阵

print(np.ones((2,6)))
#[[ 1.  1.  1.  1.  1.  1.]
# [ 1.  1.  1.  1.  1.  1.]]

（8）生成随机数，np.random下面包含了可以生成服从多种分布的随机函数

①生成0，1之间的随机数，random.random(n)

print(np.random.random(10))
#[ 0.21437959  0.09813027  0.07045995  0.61967292  0.9574697   0.66194161
#  0.05899887  0.56668386  0.99406758  0.62972476]

②生成均匀分布，np.random.rand(行,列)均匀分布默认生成0,1之间的函数

print(np.random.rand(2,3))
#[[ 0.42766455  0.30394805  0.27492911]
# [ 0.11946676  0.2762066   0.70844012]]

③生成正态分布np.random.randn（行，列）

print(np.random.randn(2,3))
#[[-1.18745328  0.01947278 -0.92818494]
 [ 1.1965783  -0.15598417  1.1105945 ]]

④生成随机整数np.random.randint（初始值，终止值）

print(np.random.randint(2,10,size=[2,5]))
#[[7 8 4 6 6]
# [5 7 9 3 4]]

3.数组的访问

①一维数组的访问

arr3=np.arange(10)
print(arr3)
print(arr3[2:4])
#[0 1 2 3 4 5 6 7 8 9]

②修改值

arr3[2:4]=100,101
print(arr3)
#[  0   1 100 101   4   5   6   7   8   9]

③倒着取

print(arr3[-1:0:-2])
#[9 7 5 3 1]

④二维数组取值

arr = np.array([[1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11]])
print(arr)
#  ':' 所有行
print(arr[:,2:4])
print(arr[1:3,2:])
#[[ 1  2  3  4  5]
# [ 4  5  6  7  8]
# [ 7  8  9 10 11]]

#[[ 3  4]
# [ 6  7]
# [ 9 10]]

#[[ 6  7  8]
# [ 9 10 11]]

⑤使用布尔值访问数组

mask = np.array([1,0,1],dtype=np.bool)
print(mask)
print(arr[mask,2])
#[[ 1  2  3  4  5]
# [ 4  5  6  7  8]
# [ 7  8  9 10 11]]
#[ True False  True]
#[3 9]

4.数组的运算 — ufunc函数

#ufunc函数称为通用函数 是一种能够对数组中所有元素进行操作的函数 ufunc函数只针对数组进行操作
#并且结果都以numpy数组进行输出 因此不需要对数组中的每一个元素进行操作，比math库中的函数更高效

①常用的ufunc函数

#四则运算

x=np.array([1,2,3])
y=np.array([2,2,2])
print(x+y)
print(x-y)
print(x*y)
print(x/y)
print('幂运算',x**y)
#[3 4 5]
#[-1  0  1]
#[2 4 6]
#[ 0.5  1.   1.5]
#幂运算 [1 4 9]

②数组的比较运算

print(x<y)
print(x==y)
print(x!=y)
print(x<=y)
print(x>=y)
#[ True False False]
#[False  True False]
#[ True False  True]
#[ True  True False]
#[False  True  True]

np.all 表示逻辑与 and

print(np.all(x==y))     #有假都为假
#False

np.any 表示逻辑或 or

print(np.any(x==y))     #有真为真
#True

5.ufunc广播机制

#广播是指不同形状的数组之间的运算方式 当时用ufunc函数镜像数组计算时 ufunc函数会对这两个数组的对应元素进行运算
#这种运算的前提是 两个数组的shape一致
#当两个元素的shape不一致时 numpy会启用广播机制

arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print(arr1.shape)
print(arr1)
#(4, 3)
#[[0 0 0]
# [1 1 1]
# [2 2 2]
# [3 3 3]]
arr2 = np.array([1,2,3])
print(arr2.shape)
print(arr2)
#(3,)
#[1 2 3]
print(arr1+arr2)
#[[1 2 3]
# [2 3 4]
# [3 4 5]
# [4 5 6]]

#第二种广播
arr3=np.arange(0,4)
print(arr3)
arr4=arr3.reshape(4,1)
print(arr4)
print(arr4+arr3)
#[0 1 2 3]
#[[0]
# [1]
# [2]
# [3]]
#[[0 1 2 3]
# [1 2 3 4]
# [2 3 4 5]
# [3 4 5 6]]