一篇文章快速入门numpy

NUMPY知识汇总

1.基础知识

1.轴

[[ 1., 0., 0.],
 [ 0., 1., 2.]]
#这是一个二维数组，里面有两个一维数组
#因为它里面有两个一维数组，因此它的第一格轴长度为2（就是一维数组个数）
#又因为一维数组里面有三个元素，因此它的第二轴的长度为3（一维数组中元素的个数）
#如果是二维的话，可以理解为行和列，行是第一维度，列是第二维度

2.list，numpy.array 与 array.array区别

• list，不限定数据类型。使用起来非常灵活，但带来的缺点是速度相对较慢，因为对每一个元素要检查数据类型；

• array.array，限定数据类型。限制了灵活性，相对速度比较高；同时array只是将存储的数据看成数组或二维数组，而数组并没有看成矩阵，也没有配备向量或矩阵相关的运算

  用来处理一维数组比较合适；

• numpy.array应运而生，操作同list、array.array；与array.array一样只存储一种数据类型，可以使用dtype属性查看

3.常用属性函数

>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
#reshape（）对于二维的可以改变行列
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
#对象名.shape(),返回每一个维度中数组有多少，二维的话就是返回行列，返回的结果是元祖
>>> a.ndim
2
#对象名.ndim()就是返回整体有多少个维度数（轴的个数）
>>> a.dtype.name
'int64'
#对象名.dtype.name 返回数组中元素的数据类型
>>> a.itemsize
8
#对象名.itemsize 返回数组中每一个元素的字节大小
>>> a.size
15
#对象名.size 用来返回有多少个元素
>>> type(a)
#type() 用来查看对象的类型
<type 'numpy.ndarray'> # 数组类型 numpy

2.数组创建

1.array()函数创建

###1.基础创建
>>> import numpy as np
>>> a = np.array([2,3,4]) #创建一维数组
>>> a= np.array([[1.5,2,3], [4,5,6]) #创建二维数组，外面是列表，里面是子列表
##当需要传入多个参数时，要用列表
***
###2.创建数组并且指定数组的类型(dtype)
>>> import numpy as np
>>> a = np.array([2,3,4],dtype=complex #一维
>>> a= np.array([[1.5,2,3], [4,5,6]],dtype=float) #二维
                 
****
 通常，数组的元素是什么最初是未知的，但它的大小是已知的。   如果有函数可以帮助我们提前初始化一些元素，就很不错
                

2.zeros（）创建0组成的数组

import numpy as np
###1.创建初始化为0的一维数组
b = np.zeros( 4 ，dtype= int) #有4个0组个一维初始化数组,并指定类型为int
###2.创建初始化为0的二维数组
b = np.zeros( (3,4) )#创建3行4列初始化为0的数组

3.ones()创建1组成的数组

import numpy as np
###1.创建初始化为0的一维数组
b = np.ones( 4 ，dtype= int) #有4个1组个一维初始化数组,并指定类型为int
###2.创建初始化为0的二维数组
b = np.zeros( (3,4) )#创建3行4列初始化为1的数组

4.empty()创建随机的空数组

import numpy as np
###1.创建初始化为0的一维数组
b = np.ones( 4 ) #有4个无意义的数组成一维初始化数组
###2.创建初始化为0的二维数组
b = np.emptys( (3,4) )#创建3行4列初始化为无意义的数组

5.arange()产生指定一维数组（适合整数）

import numpy as np
b = np.arange(1 , 10, 2) #[1,3,5,7,9]一维数组
b = np.arange( 4) #产生【0,1,2,3】一维数组
##参数讲解
1:是开始值
10:是结束值，不包括这个值
2:是跳跃的步长

6.linspace()产生指定一维数组（适合float）

import numpy as np
b = np.linspace(0.1 , 0.7, 2) #[1,3,5,7,9]一维数组
##参数讲解
0.1:是开始值
0.7:是结束值
2:是我们想要在这个区间内接受的元素数量

7.产生随机数的数组

###1.产生一维数组
import numpy as np
b = np.random.random(3) #产生3个0到1之间的随机数
###2.产生二维数组
import numpy as np
c = np.random.random( (2,3))#产生2行3列在0到1之间的随机数

3.输出数组

如果一个数组非常大时，我们输出的结果只是输出上面的一部分和下面的一部分，想要全部都输出该怎么办？

import sys
import numpy as np
np.set_printoptions(threshold=sys.maxsize) #必备
b = np.arange(10000).reshape(100,100) #实例
print(b)

4.数组间的运算（加减乘除）

1.数组和数的计算

数组中的每一个元素都与该数的的对应计算

2.相同形状的数组间计算

其实就是两个数组在相同位置上的计算

3.不同形状的数组间计算

会转换对应的数组，让他们具有相同的形状大小，然后再对应位置计算

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9qaA9VFM-1661522727720)(C:\Users\hanhan\AppData\Roaming\Typora\typora-user-images\image-20220608195101316.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nvsq2q79-1661522727722)(C:\Users\hanhan\AppData\Roaming\Typora\typora-user-images\image-20220608195110264.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EpTDVlv7-1661522727723)(C:\Users\hanhan\AppData\Roaming\Typora\typora-user-images\image-20220608195118930.png)]

4.对两个数组进行比大小

前提：如果两个数组的格式形状大小完全一样，那他们就可以比较大小（大于等于小于号）

比较结果:其实就是对应位置上比大小，结果是true和false

5.常用聚合函数

须知：对于二维以上的数组，我们可以添加参数axis，指定他们的计算是按行计算，还是按列计算

axis = 1 ：按行计算

axis = 0 ：按列计算

1.一维数组

###1.sum,max,min,mean，cumsum等
import numpy as np
b = np.arange(12) #产生4个数，构成一维数组
#sum
b.sum() #与一维数组计算没差别,返回一维数组的和
#min
b.min() #返回一维数组中的最小值 ，max与之同理
#mean # 同上

2.二维数组

###sum,max,mean等
import numpy as np
b = np.arange(12).reshape(3,4)
##sum
b.sum(axis=0) #返回的是一个列表，里面的元素是对应列上的和，构成一个列表，有多少个列，返回的结果列表中就有多少个元素,索引从0开始
b.sum(axis=1) #返回的是一个列表，里面的元素是对应行上的和，有多少个行，形成的列表中就有多少个元素

##min
b.min(axis=0) #就是返回一个列表，在列上选择最小的元素，有多少列，就有多少个元素
b.min(axis=1) #就是返回一个列表，在行上选择最小的元素，有多少行，就有多少个元素
##其他的同上

6.通用函数

其实就是一些计算公式，遇到的时候，查查即可

7.总结注意点

1. 某些操作（例如+=和 *=）会更直接更改被操作的矩阵数组而不会创建新矩阵数组。
2. 当使用不同类型的数组进行操作时，结果数组的类型对应于更一般或更精确的数组（称为向上转换的行为）。

5.索引，切片，迭代

须知：一维数组的索引从左往右是从0开始的，从右往左是从-1开始的，切片符合左闭右开的原则，迭代等这三个操作与列表没啥区别

####列表切片与索引讲解
索引从左往右是从0开始的，从右往左是从-1开始的
##1.获取列表中的一个值
a = 【1,2,3,4】
a[0] #获取第一个值为1
a[-1] #获取最后一个值为4
**********
##2.获取整个列表对象
a[:]
a[::]
a[::1] #上面的这三个办法都可以 ,结果是[1,2,3,4]

a[::-1] # 获取反向的列表 ,结果是【4,3,2,1】
**
##3.获取列表的一部分
切片要符合左闭右开的原则
#正向索引
a[0:3] # 获取三个元素 0,1,2 构成列表
a[:2] #获取两个元素，0和1 构成列表，此时索引只可以从0开始
a[1:3:1] #获取从索引1到3的（不包括3），并且跳跃步长为1
#反向索引
不太了解，后面补一下
**
##4.多层切片
其实很简单，我们对一个列表切片产生的结果，再次进行切片，这样的就是多层切片，由于每一次切片后，我们都需要把它赋值给新的变量，比较麻烦，索引我们可以把这些切片汇总到一个变量里
a = [:7][2:4] # [:7]是第一次切片，[2:4]是第二次切片

下面就开始将多维数组了，尤其是二维数组

多维的数组每个轴可以有一个索引。这些索引以逗号分隔的元组给出

1.索引与切片

索引是从0开始,无论是行，还是行里面的元素

符合左闭右开原则

逗号左边控制行，逗号右边控制列

只有：时，就是选择全部，如【0:2，：】其实就是只选择行，列选择全部

##1.获取二维数组中的某一个值
import numpy as np
b = np.arange(12).reshape(3,4)
b[ (1,2)] = b[ 1,2 ] # 获取第二行中的，第三个元素

##2.获取二维数组中的某一行
b[1,:] # 获取二维数组中第二行
##3.获取二维数组中连续几行
b[0:2,:] #获取 第一行，第二行 的元素

##3.获取二维数组中的某一列
b[:,1] #获取二维数组中的第二列

##5.获取二维数组里连续的几列
a[:,0:2] # 获取 第一列和第二列

##6.获取某几行并且取当中的某列
a[0:5,0:2] 获取第一行到第四行，并且从当中取出第一列到第二列的数据

3.迭代

迭代其实说白了就是对数组的操作然后形成新的数组

##对数组里面的每一个元素都进行操作
import numpy as np
num=np.arange（12） #产生0-12个数
new = []
for i in num.flat: #必须使用flat来对每一个元素操作
    i = i*2 # 元素进行计算
    new.append(i) # 将计算后的元素，添加到新的列表里
num1 = np.array(new) # 将产生的新列表，转换成数组
num1.reshape(3,4) # 再将产生的新数组，变成我们想要的形状

6.形状操作

1. 显示数组的形状

import numpy as np
b = np.floor(10*np.random.random((3,4)))
b.shape #会用元祖的形式，显示形状，二维就是行和列

2.改变数组形状

两种方法

##1.reshape（）方法
数组名.reshape(3,4) #变成3行4列的二维数组，不会修改原数组本身，只是返回一个修改后的新数组
##2.resize()
数组名.resize(3,4) #变成3行4列的二维数组，会修改原数组本身，返回一个修改后的新数组

7.将不同的数组叠加成一个数组

须知：一维数组的叠加跟列表的叠加差不多，这里主要将二维

##如果想要将不同的数组组合在一起，那他们在叠加时，格式是得一样的，比如想要叠加行，就需要列数相同，想要叠加列，那他们的行数得相同
###1.叠加行数:其实就是将新数组的行放在老数组的下面
import numpy as np
num1 = np.random.random((x,2))#因为是叠加行，列数相同就行，行相同不同都行
num2 = np.random.random((x,2))#因为是叠加行，列数相同就行，行相同不同都行
np.vstack( (num1,num2) ) #里面是元祖，num1放在上面，num2放在下面，列数一样，行数可同可不同 
###2.叠加列数：其实就是将新数组的列数与老数组的列数合并在一起
import numpy as np
num1 = np.random.random((x,2))#因为是叠加列，行数就行，行同不同都行
num2 = np.random.random((x,2))#因为是叠加列，行数同就行，列同不同都行
np.htack( (num1,num2) ) #里面是元祖，num1放在左边，num2放在右边，列数可同可以不同，但行数一定相同

另外一种叠加方式,其实与上面一样只是函数不同

##如果想要将不同的数组组合在一起，那他们在叠加时，格式是得一样的，比如想要叠加行，就需要列数相同，想要叠加列，那他们的行数得相同
###1.叠加行数:其实就是将新数组的行放在老数组的下面
import numpy as np
num1 = np.random.random((x,2))#因为是叠加行，列数相同就行，行相同不同都行
num2 = np.random.random((x,2))#因为是叠加行，列数相同就行，行相同不同都行
np.row_stack( (num1,num2) ) #里面是元祖，num1放在上面，num2放在下面，列数一样，行数可同可不同 

###2.叠加列数：其实就是将新数组的列数与老数组的列数合并在一起
import numpy as np
num1 = np.random.random((x,2))#因为是叠加列，行数就行，行同不同都行
num2 = np.random.random((x,2))#因为是叠加列，行数同就行，列同不同都行
np.column_stack( (num1,num2) ) #里面是元祖，num1放在左边，num2放在右边，列数可同可以不同，但行数一定相同

8.将一个数组拆解成几个较小的数组

须知：我们会使用hsplit（）函数，vsplit()函数，其中hsiplit是对列进行划分的，vsplit是对行进行划分的

1.对于一维数组

对于一维数组，我们只可以使用对列进行划分，也就是只可以使用hsplit函数

import numpy as np
num  = np.arange(12) #产生0-11个一维数组
np.hsplit( num, (2,4) )
##解释一下
num：是我们需要划分的数组
(2,4) :就是我们划分的规则，符合左闭右开原则，我们的索引是从0开始，因为我们会将一维数组的索引从0到1划分为第一个区间，索引2到3划分为第二个区间，索引从4到11划分为第三区间，结果返回的一个二维列表
（2,4,5）与上面是一样的，只不过多了一个区间，服从左闭右开的规则

2.对于二维数组

对于一个二维数组，此时他就有了行和列，因此我们可以使用hsplit和vsplit

###1.对列进行划分
import numpy as np
num  = np.random.random((2,3)) #产生了2行3列的二维数组
np.hsplit(num,(1,2)) 
num:是我们传入的划分数组
(1,2)：列索引从0开始，第一列为第一个小数组，第二列为第二个小数组，第二列往后为第三个小数组，符合左闭右开的原则
*******
np.hsplit(num,2)
num：是我们要切分的数组
2：是我们想要将这个数组按列切成几块，这里我们想要按列切成2块
*******************************
###2.对行进行划分
其实就是按着行的方向切分，列的数量全部保留
import numpy as np
num  = np.random.random((6,2)) #生成一个6行2列的二维数组
np.vsplit(num,(1,3))
num:就是我们切分的数组
(1,3):行索引从0开始，第一行为第一个小数组，第二行和第三行为第二个小数组，第三行往后为第三个小数组，符合左闭右开的原则
******************
np.vsplit(num,2)
num：是我们要切分的数组
2：是我们想要将这个数组按行切成几块，这里我们想要按列切成2块

******
如何访问我们切分好的小数组
就是利用索引
切分好数组名【索引】

9.数组的复制

有三种方式

###1."="复制
import numpy as np
a = np.arange(12).reshape(3,4)
b = a
此时b与a就是简单的赋值，并没有生成新的b对象，也没有复制a的内容，他们俩个是同一个数组，并且使用的是同一个内存地址，只是一个对象的不同名字
###2.view函数复制
b = a.view()
此时b是一个新的对象，但二者都指向了同一个内存地址，也就是说，一个对象的值变，另外一个对象也会跟着变
###3.copy函数复制
b = a.copy()
此时就是相当于新建了一个对象，并且内存地址也不一样，彼此是相互独立的

10.常用的API

自己查看

11.LESS基础

广播规则

广播允许通用功能以有意义的方式处理不具有完全相同形状的输入。

广播的第一个规则是，如果所有输入数组不具有相同数量的维度，则将“1”重复地预先添加到较小数组的形状，直到所有数组具有相同数量的维度。

广播的第二个规则确保沿特定维度的大小为1的数组表现为具有沿该维度具有最大形状的数组的大小。假定数组元素的值沿着“广播”数组的那个维度是相同的。

12.布尔索引

>>> a = np.arange(12).reshape(3,4)
>>> b = a > 4 #b产生布尔型
>>> b                                          # b is a boolean with a's shape
array([[False, False, False, False],
       [False,  True,  True,  True],
       [ True,  True,  True,  True]])
>>> a[b] #返回为true的                                  # 1d array with the selected elements
array([ 5,  6,  7,  8,  9, 10, 11])
********************
不仅可以在一维数组中使用，也可以在二维数组中使用
>>> a = np.arange(12).reshape(3,4)
>>> b1 = np.array([False,True,True])             # first dim selection
>>> b2 = np.array([True,False,True,False])       # second dim selection
>>>
>>> a[b1,:]                                   # selecting rows
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>>
>>> a[b1]                                     # same thing
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>>
>>> a[:,b2]                                   # selecting columns
array([[ 0,  2],
       [ 4,  6],
       [ 8, 10]])
>>>
>>> a[b1,b2]                                  # a weird thing to do
array([ 4, 10])