Numpy包的一些简单使用

一、安装

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())

# 结果


[ 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]

Numpy包的一些简单使用

一、安装

二、Numpy使用

2.1. numpy的基础

2.2. numpy基础运算

2.3. numpy的索引

2.4. numpy数组的合并

2.5. numpy数组分割

2.6. numpy深拷贝浅拷贝

你可能感兴趣的:(Numpy包的一些简单使用)