numpy的基础学习

---

前言

Numpy库是Python进行科学计算的基础库，它是一个由多维数组对象组成，包含数学运算、逻辑运算、形状操作、排序、选择、I/O、离散傅里叶变换、基本线性代数、基本统计运算、随机模拟等功能。本文将介绍Numpy库的基本操作和简单应用。

---

一、技巧

ctrl+/在代码前相当于添加#，在按一次取消#，可一次多行添加/减少 #号

二、代码实现

1.创建数组，获取数组维度、形状、大小和定义类型

代码如下：

import numpy as np

# 1定义一个一维数组，注意（）里加一个[]
array1=np.array([1,2,3])
# print(array1) # 输出为[1 2 3]

# 2定义一个二维数组，每一个（）里有一个[]，里面每一行用一个[]
array2 =np.array([
    [1,2,3],
    [4,5,6],
    [7,8,9],
    [10,11,12]
])
# print(array2)
"""
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]"""

# 3.定义一个三维数组
array3 = np.array([
    [[1,2,3],[4,5,6],[7,8,9],[1,1,3]],
    [[1,1,1],[2,2,2],[3,3,3],[4,4,4]],
    [[5,5,5],[6,6,6],[7,7,7],[8,8,8]]
   ])
# print(array3)
"""[[[1 2 3]
  [4 5 6]
  [7 8 9]
  [1 1 3]]

 [[1 1 1]
  [2 2 2]
  [3 3 3]
  [4 4 4]]

 [[5 5 5]
  [6 6 6]
  [7 7 7]
  [8 8 8]]]"""

# 4.获取某个数组的维度，数组名.ndim
dim1=array1.ndim
dim2=array2.ndim
dim3=array3.ndim
# print(dim1,dim2,dim3)  # 输出为1 2 3，就是它们的维数

# 5.获取某个数组的形状.数组名.shape
shape1=array1.shape
shape2=array2.shape
shape3=array3.shape
# print(shape1,shape2,shape3)
"""
输出为(3,) (4, 3) (3, 4, 3)
第一个为3，可以理解为三列
第二个为（4，3），可以理解成4行，三列
第三个为（3,4,3），可以理解为第一层元素有三个，第二层元素有四个，第三层元素有三个

"""

# 5.改变某个数组的形状,数组名.reshape((形状））
# 注意重新定义的数组size一定和原来的一样
array2_reshape=array2.reshape((6,2))
# print(array2_reshape)
"""[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]
 
 若输出array2_reshape=array2.reshape((6,3))
print(array2_reshape)则会报错"""

# 6.生成全是0的数组，并且给定形状np.zeros（（形状））
zero_array = np.zeros((3,4,5))
# print(zero_array)
"""[[[0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0.]]

 [[0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0.]]

 [[0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0.]]]"""

# 7.生成全是1的数组
one_array = np.ones((3,4,5))
# print(one_array)
"""[[[1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]]

 [[1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]]

 [[1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]]]"""

# 8.生成有序数组（相当于列表中的range（））
arange_array=np.arange(0,6).reshape((2,3))
# print(arange_array)
"""[[0 1 2]
 [3 4 5]]"""

# 9.获取某个数组共有多少个元素，数组名.size
size1=array1.size
size2=array2.size
size3=array3.size
# print(size1,size2,size3)   # 输出3 12 36

# 10.定义数组中元素的类型，array（[],dtype=np.某某）
# 获取某数组中元素的类型，数组名.dtype
# (1)整数
array4 = np.array([1,2,3],dtype=np.int) # 如果int后什么都不加，默认是32位
dtype4 = array4.dtype
# print(dtype4)  #int32

array5 = np.array([1,2,3],dtype=np.int64) # 如果int后什么都不加，默认是32位
dtype5 = array5.dtype
# print(dtype5)  #int64

# (2)浮点数
array6=np.array([1,2,3],dtype=np.float) # 如果float后什么都不加，默认是64位
dtype6=array6.dtype
print(dtype6)  # float64

# 之前生成全0数组，我们将它改为整型
zero1_array = np.zeros((3,4,5),dtype=np.int)
dtype7=zero1_array
print(zero1_array)
"""[[[0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]]

 [[0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]]

 [[0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]]]"""

2.合并与分割

代码如下（示例）：

import numpy as np
# 1.上下合并  np.vstack（（A,B))
# 注意两个数组的列数必须相同
A = np.array([
    [1,2,3],
    [4,5,6]
])

B = np.array([
    [1,1,1],
    [2,2,2]
])
C = np.vstack((A,B))
# print(C)
"""
[[1 2 3]
 [4 5 6]
 [1 1 1]
 [2 2 2]]
 """

# 2.水平合并 np.hstack((A,B))
# 注意两个数组行数必须相等
D = np.hstack((A,B))
# print(D)
"""[[1 2 3 1 1 1]
 [4 5 6 2 2 2]]"""

# 3.axis=0代表列，axis=1代表行,连接
A1 = np.array([
    [1,2,3],
    [4,5,6]
])

B1 = np.array([
    [1,1,1],
    [2,2,2]
])
C1 = np.concatenate((A1,B1),axis=0)
C2 = np.concatenate((A1,B1),axis=1)
# print(C1)
# print(C2)
"""
[[1 2 3]
 [4 5 6]
 [1 1 1]
 [2 2 2]]
[[1 2 3 1 1 1]
 [4 5 6 2 2 2]]
 """

# 4.竖直分割/水平分割  vsplit/hsplitc
A2 = np.arange(0,20).reshape((4,5)) #4行5列
C2 = np.vsplit(A2,2) # 这里的分割是平均分割(分成数组的名字，分成几块）
D2 = np.hsplit(A2,5)
# print(A2)
# print(C2)
# print(D2)
"""[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
 
[array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]]), array([[10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])]
       
       [array([[ 0],
       [ 5],
       [10],
       [15]]), array([[ 1],
       [ 6],
       [11],
       [16]]), array([[ 2],
       [ 7],
       [12],
       [17]]), array([[ 3],
       [ 8],
       [13],
       [18]]), array([[ 4],
       [ 9],
       [14],
       [19]])]
"""

# 5.使用axis进行平均分割
E = np.split(A2,2,axis=0)
F = np.split(A2,5,axis=1)
# print(E)
# print(F)
"""结果[array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]]), array([[10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])]
       
       [array([[ 0],
       [ 5],
       [10],
       [15]]), array([[ 1],
       [ 6],
       [11],
       [16]]), array([[ 2],
       [ 7],
       [12],
       [17]]), array([[ 3],
       [ 8],
       [13],
       [18]]), array([[ 4],
       [ 9],
       [14],
       [19]])]"""


# 6.不平均分割
G = np.array_split(A2,3,axis=0)
print(G)
"""结果[array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]]), array([[10, 11, 12, 13, 14]]), array([[15, 16, 17, 18, 19]])]
"""

3.索引、数组中数值的替换

import numpy as np

# 1.索引
# (1)提取数组中某个指定下标的值
array2 =np.array([
    [1,2,3],
    [4,5,6],
    [7,8,9],
    [10,11,12]
])
a = array2[1,1] # 二维数组，[]中第一个是行，第二个是列，这里面写的是第二行，第二个
#print(a) # 输出5

# (2)提取数组中某一列/行的值
b = array2[:,0] # :指的是从第一个到最后一个
# print(b) # 输出 [ 1  4  7 10] 拿第一列

c = array2[1,:]
# print(c) # 输出 [4 5 6] 拿第二行

# 2.数组中数值的替换
# （1）指定下标的数值替换为某个数
# 注意原数组会被该表
array2[1,1] = 2
# print(array2) # 将第二行，第二列替换为2
"""[[ 1  2  3]
 [ 4  2  6]
 [ 7  8  9]
 [10 11 12]]"""

# (2)将某一列/行的值全部替换
array2[:,1] = 6
# print(array2) # 第二列全为6
"""[[ 1  6  3]
 [ 4  6  6]
 [ 7  6  9]
 [10  6 12]]"""

array2[1,:] = 8
#print(array2)
"""[[ 1  6  3]
 [ 8  8  8]
 [ 7  6  9]
 [10  6 12]]"""

# (3)把数组中所有等于6的值替换成-1
array2[array2==6] = -1
# print(array2)
"""[[ 1 -1  3]
 [ 8  8  8]
 [ 7 -1  9]
 [10 -1 12]]"""

# (4)把数组中小于0的值替换成100
array2[array2<0] = 100
# print(array2)
"""[[  1 100   3]
 [  8   8   8]
 [  7 100   9]
 [ 10 100  12]]"""

# (5)把数组中所有小于2的数值替换成2，原数组不改变
array3 =np.array([
    [1,2,3],
    [4,5,6],
    [7,8,9],
    [10,11,12]
])
# clip正常情况下写两个值，一个是上限，一个是下限
# 如果想把想把小于2的值替换成2，就写一个2就行了
# array3_change = array3.clip(2)
# print(array2) # 与之前改变的对比看
# print(array3)
# print(array3_change)
"""[[  1 100   3]
 [  8   8   8]
 [  7 100   9]
 [ 10 100  12]]
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[[ 2  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]"""

# (6)把数组中大于10的值替换成10，原数组不改变
# float("-inf")是无穷小的意思，float("+inf")是无穷大的意思
# 没有下限，大于10的替换成10
# array3_change = array3.clip(float("-inf"),10)
# print(array3)
# print(array3_change)
"""[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[[ 1.  2.  3.]
 [ 4.  5.  6.]
 [ 7.  8.  9.]
 [10. 10. 10.]]"""

# (7)把数组中所有小于2的数改变成2，所有大于10的数改变成10，原数组不变
array3_change = array3.clip(2,10)
print(array3)
print(array3_change)
"""[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[[ 2  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 10 10]]"""

4.numpy的其他功能：copy、三角函数、布尔值、求和、平均值等

import numpy as np

# 1.numpy中的其他功能
#（1）copy
# copy的值不会变,在处理数据时可以先copy一份
A = np.arange(6).reshape((2,3))
B=A
C=np.copy(A)
A[A==2]=-1
# print(A)
# print(B)
# print(C)
"""[[ 0  1 -1]
 [ 3  4  5]]
[[ 0  1 -1]
 [ 3  4  5]]
[[0 1 2]
 [3 4 5]]"""

# 2.n次方
# 这个的n次方是指数组中的每个数的三次方
f = C**3
# print(C)
# print(f)
"""[[0 1 2]
 [3 4 5]]
[[  0   1   8]
 [ 27  64 125]]"""

# 3.三角函数
# 括号里要用弧度表示,π的书写np.pi
E = np.sin(30/180*np.pi)
# print(E)  # 0.49999999999999994

F = np.array([[30,60,90],[120,150,180]])
G = np.sin(F/180*np.pi)
# print(G)
"""[[5.00000000e-01 8.66025404e-01 1.00000000e+00]
 [8.66025404e-01 5.00000000e-01 1.22464680e-16]]"""

# 4.对数组中所有元素进行判断是否符合某个条件，返回的是ture或者false
g = C>2
# print(g)
"""[[False False False]
 [ True  True  True]]"""

array2 =np.array([
    [1,2,3],
    [4,5,6],
    [7,8,9],
    [10,11,12]
])
array5=np.array([[1,5,3],
                 [4,5,6],
                 [5,8,9],
                 [10,11,12]])
h = array2==array5 #对于这两个数组中的元素，对应元素进行比较
# print(h)
"""[[ True False  True]
 [ True  True  True]
 [False  True  True]
 [ True  True  True]]"""

# 5.求数组中的最大值/最小值/平均值/和/中位数
#np.max(数组名）/np.min（数组名）/np.mean（数组名）/np.sum(数组名）/np.median（数组名）
mean=np.mean(C,axis=0) # 求每列平均值
# print(mean) #[1.5 2.5 3.5]

mean1=np.mean(C) # 所有数组中元素的平均值
print(mean1) #2.5

5.数组的基本运算

import numpy as np

# 1. 数组的基本运算
# 数和数组的加减乘除，数组里每一个数都与这个数组加减乘除
A = np.arange(6).reshape((2,3))
a=1
B=a+A
# print(A)
# print(B)
"""[[0 1 2]
 [3 4 5]]
[[1 2 3]
 [4 5 6]]"""

b=2
C=b*A
# print(A)
# print(C)
"""[[0 1 2]
 [3 4 5]]
[[ 0  2  4]
 [ 6  8 10]]"""

# 一维数组和一维数组的加减乘除，对应位置加减乘除
A1=np.arange(1,4)
B1=np.arange(2,5)
C=A1*B1
# print(A1)
# print(B1)
# print(C)
"""[1 2 3]
[2 3 4]
[ 2  6 12]"""

# 一维数组和二维数组加减乘除，每一行的对应位置加减乘除
# 列数要一样
A2 = np.arange(2,5)
B2 = np.arange(0,6).reshape((2,3))
C2=A2*B2
# print(A2) #[2 3 4]
# print(B2) #[[0 1 2][3 4 5]]
# print(C2)#[[ 0  3  8][ 6 12 20]]

# 二维数组与二维数组加减乘除，每一行对应位置加减乘除
# 两二维数组必须形状完全一致
A3 = np.arange(6,12).reshape((2,3))
B3 = np.arange(0,6).reshape((2,3))
C3 = A3*B3
print(A3)
print(B3)
print(C3)
"""A3=[[ 6  7  8]
 [ 9 10 11]]
B3=[[0 1 2]
 [3 4 5]]
C3=[[ 0  7 16]
 [27 40 55]]"""

6.矩阵的相关运算

import numpy as np

# 1.矩阵的加法
# 注意，必须是两个同型矩阵才能相加
# 与数组的相加区别：行向量与列向量不能与矩阵相加，一个数不能与矩阵相加
A=np.arange(1,7).reshape((2,3))
B = np.arange(2,8).reshape((2,3))
C=A+B
# print(A)
# print(B)
# print(C)
"""[[1 2 3]
[4 5 6]]
[[2 3 4]
[5 6 7]]
[[ 3  5  7]
[ 9 11 13]]
"""
# 2.矩阵的数乘
# 和numpy中的一个数与一个数组相乘是一样的
A1 =np.arange(6).reshape((2,3))
a =2
B1=a*A1
# print(A1)
# print(B1)
"""[[0 1 2]
 [3 4 5]]
[[ 0  2  4]
 [ 6  8 10]]"""

# 3.矩阵与矩阵相乘（线性代数）
#注意区别二维数组与二维数组相乘的条件
A2=np.arange(1,13).reshape((3,4))
B2 = np.arange(2,10).reshape((4,2))
#下面两个C2方法都可以
C2=np.matmul(A2,B2)
# C2=np.dot(A2,B2)
# print(A2)
# print(B2)
# print(C2)
"""[[ 1  2  3  4]
[ 5  6  7  8]
[ 9 10 11 12]]
[[2 3]
[4 5]
[6 7]
[8 9]]
[[ 60  70]
[140 166]
[220 262]]"""

# 4.求转置矩阵
A3=np.arange(1,13).reshape((3,4))
# 有两种方法表示转置
B3=A3.T
#B3=np.transpose(A3)
# print(A3)
# print(B3)
"""[[ 1  2  3  4]
  [ 5  6  7  8]
  [ 9 10 11 12]]

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

# 5求逆矩阵，只有方阵才有逆矩阵
A4=np.array([[2,3],[4,5]])
B4=np.linalg.inv(A4)
# print(A4)
# print(B4)
"""
[[2 3]
 [4 5]]
[[-2.5  1.5]
 [ 2.  -1. ]]
"""

# 6.求方阵行列式的值
A5=np.arange(1,10).reshape((3,3))
B5=np.linalg.det(A5)
# print(B5) #6.66133814775094e-16

# 7.求线性方程组的解
A6=np.array([
    [1,-2,3,-4],
    [1,3,0,-3],
    [0,1,-1,1],
    [1,1,1,1]
])
a6=np.array([4,1,-3,6])
x=np.linalg.solve(A6,a6)
# print(x) #[-8.    4.25  8.5   1.25]

7.补充

import numpy as np

# 1.生成全是2的数组
# 之前学过生成全是0,1的数组
two_array = np.ones((2,5,2))*2
# print(two_array)
"""[[[2. 2.]
  [2. 2.]
  [2. 2.]
  [2. 2.]
  [2. 2.]]

 [[2. 2.]
  [2. 2.]
  [2. 2.]
  [2. 2.]
  [2. 2.]]]"""

# 2.numpy数组中如何对某一行或某一列进行条件赋值
# 对某一列元素进行替换,第二列大于11的值进行替换
A=np.arange(1,21).reshape((5,4))
# print(A)
A[:,1][A[:,1]>11]=100
# print(A)
"""[[  1   2   3   4]
 [  5   6   7   8]
 [  9  10  11  12]
 [ 13 100  15  16]
 [ 17 100  19  20]]"""

# 3.数组合并中维度的要求，numpy中append的用法
# 使用vstack或者hstack的时候，两个数组不一定要有同样的维度
# 但必须列数/行数相同
A1=np.arange(1,9).reshape((2,4))
B1=np.arange(1,5).reshape((1,4))
# print(A1)
# print(B1)
# C=np.vstack((A1,B1))
# print(C)
"""[[1 2 3 4]
 [5 6 7 8]]
[[1 2 3 4]]
[[1 2 3 4]
 [5 6 7 8]
 [1 2 3 4]]"""

# 使用concatenate必须两个维度相同；列数（axis=0）/行数（axis=1）相同
# C=np.concatenate((A1,B1),axis=0)
# print(C)
"""
[[1 2 3 4]
 [5 6 7 8]
 [1 2 3 4]]"""

# numpy中的append的用法（注意和列表中的append对比记忆）
# 两个数组维度必须相同，列数/行数相同
# 写法上和concatenate的区别是两个数组不需要再用括号括起来
c=np.append(A1,B1,axis=0)
print(c)
"""[[1 2 3 4]
 [5 6 7 8]
 [1 2 3 4]]"""

---

总结

以上就是我对numpy的基础学习。