0.前言

  什么是numpy呢,在机器学习中，我们经常对多维向量进行处理，如果直接用循环进行计算，会非常费时间，numpy库中含有很多矩阵的运算方法，实现起来是比循环快的多的(这是目前我理解的numpy的作用)
  其其实numpy就是矩阵的处理，也可以说是二维数组，只不过他的处理方法很快(个人理解)

1.array的属性

import numpy as np
array=np.array([[1,2,3],
                [3,2,1]])
print(array)
print(array.ndim)##维度  该为二维数组
print(array.shape)##行数和列数
print(array.size)##总共的元素和 6
a=np.array([1,2,3,4],dtype=np.double)#类型
print(a.dtype)

运行结果：

[[1 2 3]
 [3 2 1]]
2
(2, 3)
6
dtype('float64')

2.创建array

b=np.zeros((3,4))#3行4列的全为0的二维数组
c=np.ones((3,4))#全为1
d=np.empty((3,4))#为空
e=np.arange(1,20,3)#有规律的生成
f=np.arange(1,13).reshape((3,4))#三行四列从1到12,左闭右开
g=np.linspace(1,10,5)#自动生成步段,5个元素，1到10并且每个元素差的值相等 同理后边可以跟reshape
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)

运行结果：

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
[[1.50745839e-311 3.16202013e-322 0.00000000e+000 0.00000000e+000]
 [1.16709769e-312 2.37900841e+184 6.03388054e+174 2.56987636e+184]
 [8.37821381e+169 8.06859655e+169 4.42341083e-062 1.40802462e-075]]
[ 1  4  7 10 13 16 19]
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
[ 1.    3.25  5.5   7.75 10.  ]

3.基本运算

test1=np.array([10,20,30,40])
test2=np.arange(4)
print(test1,test2)
print(test1-test2)
print(test2**3)
print(np.sin(test1))#sin值
print(test1>25)#判断array中的元素是否大于或者小于或者等于一个数
t1=np.array([[1,2],[2,1]])
t2=np.arange(1,5).reshape((2,2))
print(t1*t2)#基本乘法
c_dot=np.dot(t1,t2)#矩阵乘法 另一种写法是 a.dot(b) 
print(c_dot)
print(np.sum(test1))#求和
print(np.min(test1))
print(np.max(test1))
x=np.random.random((3,4))#三行四列的0-1随机数字
print(x)
print(np.max(x,axis=0))#axis=0是找到每列最大的，1是行

h=np.arange(1,13).reshape((3,4))
print(h)
print(np.argmin(h))
print(np.argmax(h))#最大索引和最小索引值
print(np.mean(h))#平均值 或者  h.mean()
print(np.median(h))#中位数
print(np.cumsum(h))#逐步累加的过程
print(np.diff(h))#累差，前一个减后一个
print(np.transpose(h))#矩阵的转置 或者 h.T()
print(np.clip(h,5,9))#把所有数都变成5-9范围的数，小于5的变成5，大于9的变成9

运行结果：

[10 20 30 40] [0 1 2 3]
[10 19 28 37]
[ 0  1  8 27]
[-0.54402111  0.91294525 -0.98803162  0.74511316]
[False False  True  True]
[[1 4]
 [6 4]]
[[ 7 10]
 [ 5  8]]
100
10
40
[[0.80907208 0.84119995 0.66084071 0.47066325]
 [0.22864213 0.39333299 0.99280857 0.2024382 ]
 [0.08475881 0.1090048  0.13230498 0.96776618]]
[0.80907208 0.84119995 0.99280857 0.96776618]
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
0
11
6.5
6.5
[ 1  3  6 10 15 21 28 36 45 55 66 78]
[[1 1 1]
...
[[5 5 5 5]
 [5 6 7 8]
 [9 9 9 9]]

4.array的访问

print(h)
print(h[2])#第二行所有数
print(h[2][0])#第二行第0列
print(h[2,:])#第二行所有数
print(h[:,0])#第0列所有数 
print(h.flatten())#把二维矩阵转变为一行
for item in h.flat:#迭代
    print(item)

运行结果：

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

4.合并

A=np.array([1,1,1])
B=np.array([2,2,2])
C=np.vstack((A,B))#上下合并
D=np.hstack((A,B))#左右合并
print(A,B)
print(C)
print(D)

运行结果

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

5.分割

print(h)
print(np.split(h,2,axis=1))#等量分割 print(np.hsplit(h,2))
print(np.split(h,3,axis=0))#print(np.vsplit(h,3))
print(np.vsplit(h,3))
print(np.hsplit(h,2))
print("*"*80)

print(np.array_split(h,3,axis=1))#不等量分割

运行结果

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
[array([[ 1,  2],
       [ 5,  6],
       [ 9, 10]]), array([[ 3,  4],
       [ 7,  8],
       [11, 12]])]
[array([[1, 2, 3, 4]]), array([[5, 6, 7, 8]]), array([[ 9, 10, 11, 12]])]
[array([[1, 2, 3, 4]]), array([[5, 6, 7, 8]]), array([[ 9, 10, 11, 12]])]
[array([[ 1,  2],
       [ 5,  6],
       [ 9, 10]]), array([[ 3,  4],
       [ 7,  8],
       [11, 12]])]
********************************************************************************
[array([[ 1,  2],
       [ 5,  6],
       [ 9, 10]]), array([[ 3],
       [ 7],
       [11]]), array([[ 4],
       [ 8],
       [12]])]

6.浅拷贝&深拷贝

浅拷贝

a=np.arange(6)
b=a
print(b is a)
print(id(a))
print(id(b))

运行结果

True
3051148292336
3051148292336

深拷贝

c=a.copy()
print(c is a)
print(id(a))
print(id(c))

运行结果

False
3051148292336
3051178728208