一、安装
Windows安装：
pip3 install numpy scipy matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple
二、Numpy使用
使用要先导入包
import numpy as np
2.1. numpy的基础
# 创建一个数组
array01 = np.array([[1, 2, 3], [1, 2, 3]])
# 打印后没有逗号来分隔列表
print("array01", array01)
# 结果
array01 [[1 2 3]
[1 2 3]]
# 数组的维度
print("number of dim:", array01.ndim)
# 结果
number of dim: 2
# 数组的行和列(形状)
print("shape", array01.shape)
# 结果
shape (2, 3)
# 数组元素的总个数，相当于 .shape 中 n*m 的值
print("size", array01.size)
# 结果
size 6
# dtype：对象的元素类型
array02 = np.array([1, 2, 3], dtype=int)
# 打印矩阵的类型
print(array02.dtype)
# 结果
int32
# 打印一个全部为0的矩阵，参数为矩阵的shape，要用()或[]的形式填写
# array03 = np.zeros((3, 3))
array03 = np.zeros([3])
print("array03", array03)
# 结果
array03 [0. 0. 0.]
print(array03.dtype)
# 结果
float64
# 打印一个全部为1的矩阵，参数为矩阵的shape，要用()或[]的形式填写
array04 = np.ones((3, 3))
print("array04", array04)
# 结果
array04 [[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
print(array04.dtype)
# 结果
float64
# 打印一个未初始化的数组，参数为矩阵的shape，要用()或[]的形式填写，打印出的数是一个无限接近0的数
array05 = np.empty((3, 3), dtype=float, order='C')
print("array05", array05)
# 结果
array05 [[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
print(array05.dtype)
# 结果
float64
# 打印一个有序数组，数组的值是从0到11
array06 = np.arange(12)
print("array06", array06)
# 结果
array06 [ 0 1 2 3 4 5 6 7 8 9 10 11]
# 打印一个有序数组，数组的值是从2到20，步长为3
array07 = np.arange(2, 21, 3)
print("array07", array07)
# 结果
array07 [ 2 5 8 11 14 17 20]
# 打印一个有序数组，数组的值是从2到100，步长为3，重新定义shape
array08 = np.arange(2, 101, 3).reshape((3, 11))
print("array08", array08)
# 结果
array08 [[ 2 5 8 11 14 17 20 23 26 29 32]
[35 38 41 44 47 50 53 56 59 62 65]
[68 71 74 77 80 83 86 89 92 95 98]]
# numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的
# 也可以reshape
array09 = np.linspace(1, 10, 3)
print("array09", array09)
# 结果
array09 [ 1. 5.5 10. ]
2.2. numpy基础运算
# 相减，相减的两个数组shape要一致
array01 = np.array([1, 2, 3, 4, 5, 6, 7])
array02 = np.arange(7)
array03 = array02 - array01
print(array03)
# array01 [1 2 3 4 5 6 7]
# array02 [0 1 2 3 4 5 6]
# 结果
[-1 -1 -1 -1 -1 -1 -1]
# 相加，相加的两个数组shape要一致
array01 = np.array([1, 2, 3, 4, 5, 6, 7])
array02 = np.arange(7)
array03 = array02 + array01
print(array03)
# array01 [1 2 3 4 5 6 7]
# array02 [0 1 2 3 4 5 6]
# 结果
[ 1 3 5 7 9 11 13]
# 平方/幂
array01 = np.arange(7)
array02 = array01 ** 2
print("array02", array02)
# array01 [0 1 2 3 4 5 6]
# 结果
array02 [ 0 1 4 9 16 25 36]
# sin/cos
array01 = np.arange(7)
array02 = np.sin(array01)
print("array02", array02)
# array01 [0 1 2 3 4 5 6]
# 结果
array02 [ 0. 0.84147098 0.90929743 0.14112001 -0.7568025 -0.95892427
-0.2794155 ]
# 打印多少个值小于3
array01 = np.arange(7)
print(array01 < 3)
# array01 [0 1 2 3 4 5 6]
# 结果
[ True True True False False False False]
# 就是说如果小于3，对应的位置是True，如果不是，则是False
# 逐个相乘
array01 = np.arange(7)
array02 = np.arange(7)
print(array01 * array02)
# array01 [0 1 2 3 4 5 6]
# array02 [0 1 2 3 4 5 6]
# 结果
[ 0 1 4 9 16 25 36]
# 矩阵乘法
array01 = np.arange(7)
array02 = np.arange(7)
# 以下两种写法作用相同
print(np.dot(array01, array02))
print(array01.dot(array02))
# array01 [0 1 2 3 4 5 6]
# array02 [0 1 2 3 4 5 6]
# 结果
91
91
# 随机生成
# random括号中是矩阵的shape
array01 = np.random.random((2, 4))
print(array01)
# 结果
[[0.49041883 0.65577959 0.0749789 0.25122033]
[0.63311773 0.91115967 0.51406456 0.04068049]]
# 数组的总和
print(np.sum(array01))
# array01
# [[0.49041883 0.65577959 0.0749789 0.25122033]
# [0.63311773 0.91115967 0.51406456 0.04068049]]
# 结果
3.571420117123375
# 数组的最大值
print(np.max(array01))
# array01
# [[0.49041883 0.65577959 0.0749789 0.25122033]
# [0.63311773 0.91115967 0.51406456 0.04068049]]
# 结果
0.9111596735272833
# 数组的最小值
print(np.min(array01))
# array01
# [[0.49041883 0.65577959 0.0749789 0.25122033]
# [0.63311773 0.91115967 0.51406456 0.04068049]]
# 结果
0.04068048917507383
# 指定维度axis,max、min、sum同理
# axis：默认为列向（也即 axis=0），axis = 1 时为行方向的最值,也就是每一行会有一个最值，有多少行就有多少最值
print(np.max(array01, axis=1))
[0.65577959 0.91115967]
A = np.arange(2, 14).reshape((3, 4))
# 最小值的索引
print(np.argmin(A))
# A
# [[ 2 3 4 5]
# [ 6 7 8 9]
# [10 11 12 13]]
# 结果
0
# 打印平均值
print(np.mean(A))
print(A.mean())
print(np.average(A))
# A
# [[ 2 3 4 5]
# [ 6 7 8 9]
# [10 11 12 13]]
# 结果
7.5
7.5
7.5
# 中位数
print(np.median(A))
# A
# [[ 2 3 4 5]
# [ 6 7 8 9]
# [10 11 12 13]]
# 结果
7.5
"""
累加
0100numpy.cumsum(a, axis=None, dtype=None, out=None)
axis=0，按照行累加。
axis=1，按照列累加。
axis不给定具体值，就把numpy数组当成一个一维数组。
第一位输出A数组的第一位，第二位是A数组的第一位+第二位，第三位是A数组的第一位+第二位+第三位，以此类推。。。
"""
print(np.cumsum(A))
# A
# [[ 2 3 4 5]
# [ 6 7 8 9]
# [10 11 12 13]]
# 结果
[ 2 5 9 14 20 27 35 44 54 65 77 90]
"""
累差
后一个元素减去前一个元素
"""
print(np.diff(A))
# A
# [[ 2 3 4 5]
# [ 6 7 8 9]
# [10 11 12 13]]
# 结果
[[1 1 1]
[1 1 1]
[1 1 1]]
# 原来矩阵一行是四个数，计算结果一行为三个数
"""
找出非零的数
输出结果如下
(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))
会输出两个数组，第一个数组代表所有不为零的横坐标，第二个数组是纵坐标,对照着看
也就是说，A数组，所有不为零的数的下标为(0,0),(0,1),(0,2),(0,3),(1,0)....
"""
print(np.nonzero(A))
# A
# [[ 2 3 4 5]
# [ 6 7 8 9]
# [10 11 12 13]]
# 结果
(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(np.transpose(A))
print(A.T)
# A
# [[ 2 3 4 5]
# [ 6 7 8 9]
# [10 11 12 13]]
# 结果
[[ 2 6 10]
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]]
[[ 2 6 10]
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]]
# clip
# 所有小于5的数都变成是5，所有大于9的数字都变为9
print(np.clip(A, 5, 9))
# A
# [[ 2 3 4 5]
# [ 6 7 8 9]
# [10 11 12 13]]
# 结果
[[5 5 5 5]
[6 7 8 9]
[9 9 9 9]]
# 排序
B = np.random.random((3, 5))
print(B)
print(np.sort(B))
"""
计算的时候可以指定是对于行计算还是对于列计算
axis=0，按照行计算
axis=1，按照列计算
"""
# 结果
[[0.70056206 0.08774181 0.74982551 0.06551736 0.18228322]
[0.91882845 0.95398492 0.68164948 0.12950223 0.17427662]
[0.39897969 0.1183171 0.05720491 0.8894308 0.81844583]]
[[0.06551736 0.08774181 0.18228322 0.70056206 0.74982551]
[0.12950223 0.17427662 0.68164948 0.91882845 0.95398492]
[0.05720491 0.1183171 0.39897969 0.81844583 0.8894308 ]]
2.3. numpy的索引
A = np.arange(3, 15)
print(A[2])
# A [ 3 4 5 6 7 8 9 10 11 12 13 14]
# 结果
5
B = np.arange(3, 15).reshape((3, 4))
print(B[2])
# B
# [[ 3 4 5 6]
# [ 7 8 9 10]
# [11 12 13 14]]
# 结果
[11 12 13 14]
# 以下两种方式等同
print(B[2][1])
print(B[2, 1])
# B
# [[ 3 4 5 6]
# [ 7 8 9 10]
# [11 12 13 14]]
# 结果
12
12
# 代表第三行的所有数
print(B[2, :])
# B
# [[ 3 4 5 6]
# [ 7 8 9 10]
# [11 12 13 14]]
# 结果
[11 12 13 14]
# 第二列的所有数
print(B[:, 1])
# B
# [[ 3 4 5 6]
# [ 7 8 9 10]
# [11 12 13 14]]
# 结果
[ 4 8 12]
# 代表第二行的第二到第四个数（包含第二个数，不包含第四个数）
print(B[1, 1:3])
# B
# [[ 3 4 5 6]
# [ 7 8 9 10]
# [11 12 13 14]]
# 结果
[8 9]
# 循环
# 打印每一行
for row in B:
print(row)
# B
# [[ 3 4 5 6]
# [ 7 8 9 10]
# [11 12 13 14]]
# 结果
[3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]
# B
# [[ 3 4 5 6]
# [ 7 8 9 10]
# [11 12 13 14]]
# 没有迭代列，但是可以通过迭代B的transpose的行，达到迭代B的列的目的
print(B.T)
# 结果
[[ 3 7 11]
[ 4 8 12]
[ 5 9 13]
[ 6 10 14]]
for column in B.T:
print(column)
# 结果
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]
[ 6 10 14]
print(B.flat)
print(B.flatten())
# 结果
<numpy.flatiter object at 0x000001D590A53C60>
[ 3 4 5 6 7 8 9 10 11 12 13 14]
# 打印B元素的每一项
for item in B.flat:
print(item)
# B
# [[ 3 4 5 6]
# [ 7 8 9 10]
# [11 12 13 14]]
# 结果
3
4
5
6
7
8
9
10
11
12
13
14
2.4. numpy数组的合并
A = np.array([1, 1, 1])
B = np.array([2, 2, 2])
# 上下合并，就是把A和B合并成一个2*3的二维数组
C = np.vstack((A, B))
print(C.shape)
# A [1 1 1]
# B [2 2 2]
# C
# [[1 1 1]
# [2 2 2]]
# 结果
(2, 3)
# 左右合并
D = np.hstack((A, B))
print(D.shape)
# A [1 1 1]
# B [2 2 2]
# D [1 1 1 2 2 2]
# 结果
(6,)
"""
为数组多加一个轴
可以把[1,1,1]的数组变为
[[1]
[1]
[1]]
"""
print(A[:, np.newaxis])
# A [1 1 1]
# 结果
[[1]
[1]
[1]]
A = np.array([1, 1, 1])[:, np.newaxis]
B = np.array([2, 2, 2])[:, np.newaxis]
C = np.vstack((A, B))
print(C.shape)
# A
# [[1]
# [1]
# [1]]
# B
# [[2]
# [2]
# [2]]
# C
# [[1]
# [1]
# [1]
# [2]
# [2]
# [2]]
# 结果
(6, 1)
D = np.hstack((A, B))
print(D.shape)
# A
# [[1]
# [1]
# [1]]
# B
# [[2]
# [2]
# [2]]
# D
# [[1 2]
# [1 2]
# [1 2]]
# 结果
(3, 2)
# 多个数组合并
print(np.concatenate((A, B, A, B, B), axis=0))
print(np.concatenate((A, B, A, B, B), axis=1))
# 结果
[[1]
[1]
[1]
[2]
[2]
[2]
[1]
[1]
[1]
[2]
[2]
[2]
[2]
[2]
[2]]
[[1 2 1 2 2]
[1 2 1 2 2]
[1 2 1 2 2]]
2.5. numpy数组分割
A = np.arange(12).reshape((3, 4))
print(A)
# 结果
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
# 1为纵向分割，分割成2等段
print(np.split(A, 2, axis=1))
# A
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 结果
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
# 0为横向分割，分割成3等段
print(np.split(A, 3, axis=0))
# A
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 结果
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
# 不等量的分割
# 纵向分割，分割成不等的3段
print(np.array_split(A, 3, axis=1))
# A
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 结果
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
# 其他分割方法
print(np.vsplit(A, 3))
print(np.hsplit(A, 2))
# A
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 结果
[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]])]
2.6. numpy深拷贝浅拷贝
A = np.arange(4)
print(A)
# 结果
[0 1 2 3]
# 赋值
B = A
C = A
D = A
print(B, C, D)
# 结果
[0 1 2 3] [0 1 2 3] [0 1 2 3]
A[0] = 11
print(A)
print(B, C, D)
# 原来的A [0 1 2 3]
# 结果
[11 1 2 3]
[11 1 2 3] [11 1 2 3] [11 1 2 3]
# 深拷贝
B = A.copy()
# B [11 1 2 3]
# A [11 1 2 3]
A[1] = 232323
print(A)
print(B)
# 结果
[ 11 232323 2 3]
[11 1 2 3]
网友评论