Numpy库的使用

前言

Numpy库是python中一个非常重要的库,它提供了一个多维数组（ndarray）数据类型，以及关于多维数组的操作，NumPy 已经成为其他大数据和机器学习模块的基础。

如果不想安Numpy库的,而你的电脑里没有安装python语言的,我们可以使用Anaconda,Anaconda里包含了很多我们要用到的科学包,包括了panda,numpy等,Anaconda可以在它的官网下载,速度可能会较慢.

官网地址为:https://www.anaconda.com/

安装Anaconda的教程可以看这篇文章:https://blog.csdn.net/qq_39610888/article/details/80805356

如果想看视频的可以去b站看这个视频:https://www.bilibili.com/video/av23124018?from=search&seid=17113017816135374394

安装完,我们就能在anaconda自带的juptyer里写代码了.

numpy的数组属性

在使用numpy我们需要像java一样,先进行导包

import numpy as np

numpy我们数组创建的常规创建方法

array=np.array([[1,2,3],
               [4,5,6],
               [7,8,9]])

print(array)

输出结果

[[1 2 3]
 [4 5 6]
 [7 8 9]]

这里我们的第一个array数组就创建好了.

我们可以使用numpy里的基本属性来获取我们新建数组的一些信息

ndarray.ndim

NumPy 数组的维数称为秩（rank），一维数组的秩为 1，二维数组的秩为 2，以此类推。

print(array.ndim)

ndarray.ndim 用于返回数组的维数，等于秩。

输出结果为：

2

ndarray.shape

表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。

ndarray.shape 也可以用于调整数组大小。

print(array.shape)#代表矩阵的维度

输出结果为：

(3, 3)

ndarray.size

数组元素的总个数，相当于 .shape 中 n*m 的值

print(array.size)#代表数组元素的总个数

输出结果为：

9

ndarray.dtype

ndarray 对象的元素类型

print(array.dtype)#代表矩阵中元素的属性

输出结果为：

int32

numpy的数据类型

numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。下表列举了常用 NumPy 基本类型。

创建array的方法

numpy.zeros

创建指定大小的数组，数组元素以 0 来填充：

import numpy as np
zero=np.zeros((2,3))#生成2行3列全为0的矩阵
print(zero)

输出结果为：

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

numpy.ones

创建指定形状的数组，数组元素以 1 来填充：

import numpy as np
one=np.ones((3,4))#生成3行4列全为1的矩阵
print(one)

输出结果为：

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

numpy.empty

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

import numpy as np
empty=np.empty((3,2))#生成3行2列全都接近0（不等于0）的矩阵
print(empty)

输出结果为：

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

numpy.arange

numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：

numpy.arange(start, stop, step, dtype)

根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

参数说明：

参数	描述
start	起始值，默认为0
stop	终止值（不包含）
step	步长，默认为1
dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

实例

生成 0 到 9 的数组:

import numpy as np
e=np.arange(10)
print(e)

输出结果如下：

[0 1 2 3 4 5 6 7 8 9]

生成 4到 11 的数组:

import numpy as np
f=np.arange(4,12)
print(f)

输出结果如下：

[ 4  5  6  7  8  9 10 11]

生成 1到 19 (每生成一个数字间隔3个数字)的数组:

import numpy as np
g=np.arange(1,20,3)
print(g)

输出结果如下：

[ 1  4  7 10 13 16 19]

Numpy 数组操作

修改数组形状

numpy.reshape

numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下：

numpy.reshape(arr, newshape, order=‘C’)

• arr：要修改形状的数组
• newshape：整数或者整数数组，新的形状应当兼容原有形状
• order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。

import numpy as np
h=np.arange(8).reshape(4,2)#重新定义矩阵的形状
print(h)

输出结果如下：

[[0 1]
 [2 3]
 [4 5]
 [6 7]]

翻转数组

numpy.transpose

numpy.transpose 函数用于对换数组的维度，格式如下：

numpy.transpose(arr, axes)

• arr：要操作的数组
• axes：整数列表，对应维度，通常所有维度都会对换。

实例

import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('原数组：')
print (a )
print ('\n')
 
print ('对换数组：')
print (np.transpose(a))

输出结果如下：

原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


对换数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

ndarray.T

一维数组不能转置

import numpy as np
arr1=np.array([1,2,3])
arr1.T
print(arr1)#一维的array不能转置

输出结果如下：

[1 2 3]

numpy.ndarray.T 类似 numpy.transpose

import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('原数组：')
print (a)
print ('\n')
 
print ('转置数组：')
print (a.T)

输出结果如下：

原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


转置数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

改变维度

使用np.newaxis()函数

例子:

import numpy as np
arr1=np.array([1,2,3])
arr_1=arr1[np.newaxis,:]#改变维度,在行这里添加一个维度，使其变成1行3列
print(arr_1)
print(arr_1.shape)

输出结果如下：

[[1 2 3]]
(1, 3)

import numpy as np
arr1=np.array([1,2,3])
arr_2=arr1[:,np.newaxis]#在列这里添加一个维度，使其变成3行1列
print(arr_2)
print(arr_2.shape)

输出结果如下：

[[1]
 [2]
 [3]]
(3, 1)

使用

例子：np.atleast_2d()和np.atleast_3d()函数

print(arr1)#原数据，arr1是一维数据
arr_31=np.atleast_2d(arr1)#把arr1变成二维数据
arr_32=np.atleast_3d(arr1)#把arr1变成三维数据

print(arr_31)
print(arr_32)

print(arr_31.T)#二维数据转置
print(arr_32.T)#三维数据转置

输出结果如下：

[1 2 3]

[[1 2 3]]

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

numpy的基本运算

先创建数组

import numpy as np
arr1=np.array([[1,2,3],
              [4,5,6]])
arr2=np.array([[1,1,2],
              [2,3,3]])
print(arr1)
print(arr2)

输出结果如下：

[[1 2 3]
 [4 5 6]]
[[1 1 2]
 [2 3 3]]

加法

print(arr1+arr2)

输出结果如下：

[[2 3 5]
 [6 8 9]]

减法

print(arr1-arr2)

输出结果如下：

[[0 1 1]
 [2 2 3]]

乘法

print(arr1*arr2)

输出结果如下：

[[ 1  2  6]
 [ 8 15 18]]

次方

print(arr1**arr2)

输出结果如下：

[[  1   2   9]
 [ 16 125 216]]

相除

print(arr1/arr2)

输出结果如下：

[[1.         2.         1.5       ]
 [2.         1.66666667 2.        ]]

求余

print(arr1%arr2)

输出结果如下：

[[0 0 1]
 [0 2 0]]

整除

print(arr1//arr2)

输出结果如下：

[[1 2 1]
 [2 1 2]]

整体加

print(arr1+2)#所有的元素都加2

输出结果如下：

[[3 4 5]
 [6 7 8]]

整体乘

print(arr1*10)#所有的元素都乘以10

输出结果如下：

[[10 20 30]
 [40 50 60]]

判断大小

arr3=arr1>3#判断那个元素大于3
print(arr3)

输出结果如下：

[[False False False]
 [ True  True  True]]

numpy.dot()

numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。

先定义一个arr4

import numpy as np
arr4=np.ones((3,5))
print(arr4)

输出结果如下：

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

np.dot(arr1,arr4)#矩阵乘法

输出结果如下：

array([[ 6.,  6.,  6.,  6.,  6.],
       [15., 15., 15., 15., 15.]])

对于矩阵乘法忘记了的或者了解不深的可以看这篇文章：https://www.cnblogs.com/alantu2018/p/8528299.html

随机数生成及矩阵的运算

np.random.random()函数

import numpy as np
samolel=np.random.random((3,2))#生成3行2列的随机数，范围（0-1）
print(samolel)

输出结果如下：

[[0.6150121  0.59427834]
 [0.58806337 0.892053  ]
 [0.59315305 0.92415359]]

numpy.random.standard_normal()函数用法

import numpy as np
samole2=np.random.normal(size=(3,2))#生成3行2列的随机数，符合标准正态分布
print(samole2)

输出结果如下：

[[ 0.36192863 -0.30079782]
 [ 0.21587959 -0.15799396]
 [-0.87615964  1.23683354]]

矩阵的运算

对于矩阵进行求和

np.sum(samolel)#对于samolel中的元素进行求和

输出结果如下：

4.206713449491107

对矩阵中的列进行求和

np.sum(samolel,axis=0)#当axis=0时是对于列，axis=1对于行，在这里是对列求和

输出结果如下：

array([1.79622852, 2.41048493])

对矩阵中的列进行行求和

np.sum(samolel,axis=1)#在这里是对行求和

输出结果如下：

array([1.20929044, 1.48011637, 1.51730664])

提取矩阵中的最小值

np.min(samolel)#提取samolel中的最小值

输出结果如下：

0.5880633706006644

提取矩阵中的最大值

np.max(samolel)#提取samolel中的最大值

输出结果如下：

0.9241535872093841

求矩阵中的平均值

print(np.mean(samolel))#求所有元素的平均值
print(samolel.mean())

输出结果如下：

0.7011189082485179
0.7011189082485179

求矩阵中的中位数

np.median(samolel)#求所有元素的中位数

输出结果如下：

0.6046452201028809

对于矩阵的数组就行开方

np.sqrt(samolel)#开方

输出结果如下：

array([[0.78422707, 0.77089451],
       [0.7668529 , 0.94448558],
       [0.7701643 , 0.96132907]])

对于矩阵的进行排序

np.sort(samolel)#排序

输出结果如下：

array([[0.39407608, 0.72871605],
       [0.48484466, 0.73652244],
       [0.19709554, 0.44424115]])

生成1行10列从1到10的随机数

import numpy as np
samole4=np.random.randint(0,10,size=(1,10))
print(samole4)

输出结果如下：

[[4 1 3 1 3 9 8 2 3 0]]

对于samole4使用np.clip()函数

np.clip(samole4,2,7)#小于2的元素变成2，大于7的元素变成7

输出结果如下：

array([[7, 7, 2, 6, 2, 5, 2, 5, 7, 6]])

np.clip()函数

numpy.clip(a, a_min, a_max, out=None)

• 参数说明
• a : 输入的数组
• a_min: 限定的最小值 也可以是数组 如果为数组时 shape必须和a一样
• a_max:限定的最大值 也可以是数组 shape和a一样
• out：剪裁后的数组存入的数组

numpy的索引和切片，合并

索引

一维数组的索引

先新建一个array数组

import numpy as np
arr1=np.arange(2,14)
print(arr1)

输出结果如下：

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

获取位置在2的数据

print(arr1[2])#第二个位置的数据

输出结果如下：

4

获取第一到第三个位置的数据

print(arr1[1:4])#第一到第三个位置的数据，【1:4】不会包括4

输出结果如下：

[3 4 5]

获取第二个到倒数第一个位置的数据

print(arr1[2:-1])#第二到倒数第一个位置的数据

输出结果如下：

[ 4  5  6  7  8  9 10 11 12]

获取前5个数据

print(arr1[:5])#前5个数据

输出结果如下：

[2 3 4 5 6]

获取最后两个数据

print(arr1[-2:])#取最后两个数据

输出结果如下：

[12 13]

二维数组的索引

把之前的一维数组变为二维数组

arr2=arr1.reshape(3,4)
print(arr2)

输出结果如下：

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

获取第一行数据

对于一维数组而言,索引[1]是获取第一位的数据,而对于二维数组索引[1]是获取第一行的数据

print(arr2[1])#第一行

输出结果如下：

[6 7 8 9]

想要获取一个数据的话就要写清在二维数组的某一行某一列

例如:

获取第一行第一列的数据

print(arr2[[1][1])#第一行的第一列

输出结果如下：

7

获取第一行第二列的数据

print(arr2[1,2])#第一行的第二列

输出结果如下：

8

获取所有行的第二列

print(arr2[:,2])#所有行的第二列

输出结果如下：

[ 4  8 12]

切片

新建一个数组

import numpy as np
arr1=np.arange(12).reshape(3,4)
print(arr1)

输出结果如下：

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

按列切片

arr2,arr3=np.split(arr1,2,axis=1)#按列方向分割,分成2份
print(arr2)
print(arr3)

输出结果如下：

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

按行切片

arr4,arr5,arr6=np.split(arr1,3,axis=0)#按行方向分割,分成3份
print(arr4)
print(arr5)
print(arr6)

输出结果如下：

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

可能报错的地方

但是如果我们本身的数组,无法在我们的要求下进行切片会报错

例如：

arr2,arr3,arr4=np.split(arr1,3,axis=1)#按列方向分割,分成3份
print(arr2)
print(arr3)
print(arr4)

输出结果如下：

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
C:\ProgramData\Anaconda3\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
    842     try:
--> 843         len(indices_or_sections)
    844     except TypeError:

TypeError: object of type 'int' has no len()

During handling of the above exception, another exception occurred:

ValueError                                Traceback (most recent call last)
<ipython-input-6-62c15d9e9149> in <module>
----> 1 arr2,arr3,arr4=np.split(arr1,3,axis=1)#按列方向分割,分成2份
      2 print(arr2)
      3 print(arr3)
      4 print(arr4)

C:\ProgramData\Anaconda3\lib\site-packages\numpy\lib\shape_base.py in split(ary, indices_or_sections, axis)
    847         if N % sections:
    848             raise ValueError(
--> 849                 'array split does not result in an equal division')
    850     res = array_split(ary, indices_or_sections, axis)
    851     return res

ValueError: array split does not result in an equal division

这就是本身数组无法被切分为3份，所以报错了

而我们一定要把arr1切分为3份的话，我们可以使用np.array_split()函数

arr7,arr8,arr9=np.array_split(arr1,3,axis=1)#按列分割,分成3份,不等分
print(arr7)
print(arr8)
print(arr9)

输出结果如下：

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

这样arr1会被强制切分为3份

其他切分方法

vsplit和hsplit

arrv1,arrv2,arrv3=np.vsplit(arr1,3)#按行分割
print(arrv1)
print(arrv2)
print(arrv3)

输出结果如下：

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

arrh1,arrh2=np.hsplit(arr1,2)#按列分割
print(arrh1)
print(arrh2)

输出结果如下：

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

合并

先新建数组

行合并

import numpy as np
arr1=np.array([1,2,3])
arr2=np.array([4,5,6])
arr3=np.vstack((arr1,arr2))#行合并
print(arr3)
print(arr3.shape)

输出结果如下：

[[1 2 3]
 [4 5 6]]
(2, 3)

列合并

arr4=np.hstack((arr1,arr2))#列合并
print(arr4)
print(arr4.shape)

输出结果如下：

[1 2 3 4 5 6]
(6,)

也可以使用concatenate()函数合并

arr=np.concatenate((arr1,arr2,arr1))
print(arr)

输出结果如下：

[1 2 3 4 5 6 1 2 3]

但是注意使用concatenate()函数合并，array数组的维度要相同，array的形状要匹配

numpy数组的迭代

新建一个数组

import numpy as np
arr=np.random.randint(0,20,size=(3,4))
print(arr)

输出结果如下：

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

对于arr数组进行迭代行

for i in arr:#迭代行
    print(i)

输出结果如下：

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

对于arr数组进行迭代列

for i in arr.T:#使用转置，来迭代列
    print(i)

输出结果如下：

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

对于arr数组一个一个元素进行迭代

for i in arr2.flat:#一个一个元素的迭代
    print(i)

输出结果如下：

2
3
4
5
6
7
8
9
10
11
12
13

numpy的浅拷贝和深拷贝

直接上例子

import numpy as np
a=np.array([1,2,3])
b=arr1	#arr1和arr2共享一块内存,浅拷贝
b[0]=5
print(a)
print(b)

输出结果如下：

[5 2 3]
[5 2 3]

可以看到，改变a后，b的值也跟着变了，这是为什么呢？

实际上，变量a中并没有存储任何的值，它只是指向了一个内存地址，而这个地址里存储着array具体的内容，当把a赋值给b的时候，实际上是把a指向内存中某对象的链接赋给了b，也就是说，现在a和b都指向了同一个对象。

因此，在改变了内存中array的值后，而a与b都引用了该array对象，所以都一起发生了变化

这种将内存引用赋值给另一个变量的操作叫做浅拷贝

c=a.copy()#深拷贝
c[0]=10

print(a)
print(c)

输出结果如下：

[5 2 3]
[10  2  3]
a引用的对象的地址： 2130290221504
c引用的对象的地址： 2130290057088

深拷贝呢，其实就是在赋值的时候，不把同一个内存对象的引用赋值给另一个变量，令两个变量所指向的对象不一样，更改值的时候不相互影响，这种操作就是深拷贝

copy()会创建a的一个副本，也就是创建一个一模一样的array对象，存储到内存的另一个地址中，然后将这个副本的地址赋值给c

目前我对于numpy库的学习到这里也就结束了,当后面学的更深入的时候,可能还会更新,本文写的可能不是很好,但还是感谢大家的阅读