总目录：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]
<numpy.flatiter object at 0x00000236DB4A21D0>
'''
#我们发现， 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]])]
'''