总目录：https://www.jianshu.com/p/e406a9bc93a9
Python - 子目录：https://www.jianshu.com/p/50b432cb9460
numpy有啥用
numpy是一个c语言写的科学计算库，比Python自带的计算操作还要快。用c语言写的Python调用c语言写的numpy，二倍的快乐。
而且numpy自带矩阵，比列表与字典计算快10-100倍。
numpy属性
我们先看一下array有哪些基础属性。
import numpy as np
#定义一个array
array = np.array([[1,2,3],
[4,5,6]])
print('array:',array)
print('他的维度是:',array.ndim)
print('他的分布是:',array.shape)
print('他的长度是:',array.size)
输出结果：
--------
array: [[1 2 3]
[4 5 6]]
他的维度是: 2
他的分布是: (2, 3)
他的长度是: 6
numpy创建array
在看这一节前，要先弄懂两个东西，一个叫矩阵（matrix），一个叫数组（array）。
在numpy中，矩阵是数组的分支，一维的数组，多维的叫矩阵，矩阵的操作数组完全兼容。而且数组操作比矩阵灵活。
官方建议大家如果两个可以通用，那就选择array，因为array更灵活，速度更快。
import numpy as np
#创建一个数组，dtype用来指定数组内的元素类型，数组内的元素类型必须一致
array = np.array([1.7,2,3],dtype=np.int64)
print(array)
print('查看数组的类型：',array.dtype)
"""
[1 2 3]
查看数组的类型： int64
"""
#创建一个矩阵
array = np.array([[1,2,3],
[4,5,6]])
print(array)
"""
[[1 2 3]
[4 5 6]]
"""
#生成一个空矩阵
a = np.zeros((3,4))
print(a)
"""
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
"""
#生成一个空矩阵,所有的值为整型
a = np.zeros((3,4),dtype=np.int64)
print(a)
"""
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
"""
#生成一个指定范围的数组
a = np.arange(10,20,2)
print(a)
"""
[10 12 14 16 18]
"""
#生成一个指定范围的矩阵
a = np.arange(10,20).reshape((2,5))
print(a)
"""
[[10 11 12 13 14]
[15 16 17 18 19]]
"""
#生成一个从头到尾均分为多少段的数组
a = np.linspace(1,10,5)
print(a)
"""
[1. 3.25 5.5 7.75 10. ]
"""
#他也可以使用reshape()，将他转换为一个矩阵
#随机生成
a = np.random.random((2,4))
print(a)
"""
[[0.79736911 0.2328766 0.83042785 0.78905984]
[0.56169946 0.24631133 0.47419514 0.88894159]]
"""
numpy的基础运算
运算分成了两部分，第一部分是数组的运算，第二部分是矩阵的运算。矩阵的运算牵扯到线代的一些东西。
import numpy as np
#数组的运算，数组的运算就是同位运算，两个进行操作的数组必须同长。
a = np.array([10,20,30,40])
b = np.arange(1,5)
#相加
c = a + b
print(c)
"""
[11 22 33 44]
"""
#相减
c = a - b
print(c)
"""
[ 9 18 27 36]
"""
#相乘
c = a * b
print(c)
"""
[11 22 33 44]
"""
#相除
c = a // b
print(c)
"""
[10 10 10 10]
"""
#平方
c = b ** 2
print(c)
"""
[ 1 4 9 16]
"""
#逻辑判断
c = b >= 3
print(c)
"""
[False False True True]
"""
#矩阵的运算
a = np.array([[10,20],
[30,40]])
b = np.arange(1,5).reshape((2,2))
#相加
c = a + b
print(c)
"""
[[11 22]
[33 44]]
"""
#相减
c = a - b
print(c)
"""
[[ 9 18]
[27 36]]
"""
#相乘
#矩阵的乘法是左行右列式运算。
c = np.dot(a,b)
print(c)
"""
[[ 70 100]
[150 220]]
"""
#相除
c = np.divide(a,b)
print(c)
"""
[[10. 10.]
[10. 10.]]
"""
#地板除
c = np.floor_divide(a,b)
print(c)
"""
[[10 10]
[10 10]]
"""
#取模
c = np.remainder(a,b)
print(c)
"""
[[0 0]
[0 0]]
"""
#平方
c = b ** 2
print(c)
"""
[[ 1 4]
[ 9 16]]
"""
#逻辑判断
c = b >= 3
print(c)
"""
[[False False]
[ True True]]
"""
这里是一个矩阵×的示意图，很容易理解，左行右列。
矩阵乘法示意：
假设: A = 1 2
3 4
B = 5 6
7 8
A * B = 1 * 5 + 2 * 7, 1 * 6 + 2 * 8
3 * 5 + 4 * 7, 3 * 6 + 4 * 8
= 5 + 14, 6 + 18
15 + 28, 18 + 32
= 19 24
43 50
同时还有一些通用的函数。
import numpy as np
a = np.arange(2,14).reshape((3,4))
#求和
print('sum:',np.sum(a))
'''
sum: 90
'''
#最大值
print('max:',np.max(a))
'''
max: 13
'''
#最小值
print('min:',np.min(a))
'''
min: 2
'''
#平均值
print('avg:',np.average(a))
print('avg:',np.mean(a))
'''
avg: 7.5
avg: 7.5
'''
#中位数
print('median:',np.median(a))
'''
median: 7.5
'''
#累加
print('cumsum:',np.cumsum(a))
'''
cumsum: [ 2 5 9 14 20 27 35 44 54 65 77 90]
'''
#累差
print('diff:',np.diff(a))
'''
diff: [[1 1 1]
[1 1 1]
[1 1 1]]
'''
#得到最小值的索引
print('min_index:',np.argmin(a))
'''
min_index: 0
'''
#得到最大值的索引
print('max_index:',np.argmax(a))
'''
max_index: 11
'''
#非零 第一个array表示x，第二个array表示y。
print('nonzero:',np.nonzero(a))
'''
nonzero: (array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
'''
#排序
print('sort:',np.sort(a))
'''
sort: [[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
'''
#行列颠倒
print('transpose:',np.transpose(a))
'''
transpose: [[ 2 6 10]
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]]
'''
#数值范围 把所有小于5的数重写成5，所有大于9的重写成9
print('clip:',np.clip(a,5,9))
'''
clip: [[5 5 5 5]
[6 7 8 9]
[9 9 9 9]]
'''
#在每一行中求和（在相同维度）
print('sum:',np.sum(a,axis=1))
'''
sum: [14 30 46]
'''
#在每一列中求和
print('sum:',np.sum(a,axis=0))
'''
sum: [18 21 24 27]
'''
numpy的索引
同样，无论数组还是矩阵，他们都是序列，是序列，就有索引。
import numpy as np
a = np.arange(3,15).reshape((3,4))
#第一个索引表示行，第二个表示列
print(a[0])
print(a[0,:])
'''
[3 4 5 6]
[3 4 5 6]
'''
#取某一个元素
print(a[0][0])
print(a[0,0])
'''
3
3
'''
#取列
print(a[:,0])
'''
[ 3 7 11]
'''
#指定行取列
print(a[0,1:3])
'''
[4 5]
'''
#for循环遍历
for row in a:
print(row)
'''
[3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]
'''
for rows in a:
for row in rows:
print(row,end=' ')
print()
#两层for循环的话，时间复杂度就是0(n**2)了，这就需要另外一个函数，平铺
for row in a.flatten():
print(row,end=' ')
print()
'''
3 4 5 6 7 8 9 10 11 12 13 14
'''
for row in a.flat:
print(row,end=' ')
print()
'''
3 4 5 6 7 8 9 10 11 12 13 14
'''
#这两个函数都能进行平铺的话，有什么区别呢
print(a.flatten())
print(a.flat)
'''
[ 3 4 5 6 7 8 9 10 11 12 13 14]
'''
#我们发现， flatten() 返回的是值， flat 返回的是一个指针 这是因为flat返回的是一个迭代器
array的合并
import numpy as np
a = np.array([1,1,1])
b = np.array([2,2,2])
#上下合并
print('上下合并:',np.vstack((a,b)))
'''
上下合并: [[1 1 1]
[2 2 2]]
'''
#左右合并
print('左右合并:',np.hstack((a,b)))
'''
左右合并: [1 1 1 2 2 2]
'''
#但是这样的左右合并好像和我们想的不大一样
a = np.array([1,1,1])[:,np.newaxis]
b = np.array([2,2,2])[:,np.newaxis]
print('左右合并:',np.hstack((a,b)))
'''
左右合并: [[1 2]
[1 2]
[1 2]]
'''
array的分割
import numpy as np
a = np.arange(12).reshape((3,4))
#分割 对列进行分割，分成两块
print(np.split(a,2,axis=1))
'''
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
'''
#分割 对列进行分割，分成两块
print(np.split(a,3,axis=0))
'''
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
'''
#我们上面的分割，都是进行等量分割，那么怎么进行不等量分割呢
print(np.array_split(a,3,axis=1))
'''
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
'''
print(np.array_split(a,2,axis=0))
'''
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
'''
#处理上面的分割方法，还有一种分割方法
print('横向分割',np.vsplit(a,3))
print('纵向分割',np.hsplit(a,2))
'''
横向分割 [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
纵向分割 [array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
'''