近万字的Numpy总结——边学边练

た入场券 2023-01-16 09:56 246阅读 0赞

前言：

> 作者：神的孩子在歌唱  
> 大家好，我叫**陈运智**，大家可以叫我**小智**

### Numpy大汇总 ###

*   *  一. Naddary结构总结
     *   *  1.1 属性
         *  1.2 形状
         *  1.3类型
     *  二. 基本操作
     *   *  2.1 生成0和1的数组zeros，ones
         *  2.2 转化现有的数组 array和asarray
         *  2.3 生成固定范围的数组 linspace
         *  2.4 生成随机数组 random
         *   *  2.4.1 rand()
             *  2.4.2 uniform()
             *  2.4.3 randint()
     *  三. 正态分布创建方式
     *  四. 数组的索引和切片
     *   *  4.1 形状修改 reshape 和 T
         *  4.2 类型修改 astype
         *  4.3 数组去重 unique
     *  五. ndarray运算
     *   *  5.1 逻辑运算
         *  5.2 通用判断函数 np.all()相当于and ,np.any() 相当于or
         *  5.3 np.where（三元运算符）
         *  5.4 统计运算案列：股票涨跌幅
     *  六. 数组间的运算
     *   *  6.1 广播机制
         *  6.2 矩阵运算 matmul 和 dot

## 一. Naddary结构总结 ##

首先我们得导入包

import numpy as np

### 1.1 属性 ###

> 使用以下函数可以打印出数组的属性

<table> 
 <thead> 
  <tr> 
   <th align="center">属性名字</th> 
   <th align="center">属性解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">ndarray.shape</td> 
   <td align="center">数组维度的元组</td> 
  </tr> 
  <tr> 
   <td align="center">ndarray.ndim</td> 
   <td align="center">数组维数</td> 
  </tr> 
  <tr> 
   <td align="center">ndarray.size</td> 
   <td align="center">数组中的元素数量</td> 
  </tr> 
  <tr> 
   <td align="center">ndarray.itemsize</td> 
   <td align="center">一个数组元素的长度（字节）</td> 
  </tr> 
  <tr> 
   <td align="center">ndarray.dtype</td> 
   <td align="center">数组元素的类型</td> 
  </tr> 
 </tbody> 
</table>

列:  
![在这里插入图片描述][20210620205814934.png]

### 1.2 形状 ###

这里说的形状就是他的维度

列：

![在这里插入图片描述][20210620205958465.png]

### 1.3类型 ###

![在这里插入图片描述][20210620210115535.png]

--------------------

<table> 
 <thead> 
  <tr> 
   <th align="center">名称</th> 
   <th align="center">描述</th> 
   <th align="center">简写</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">np.bool</td> 
   <td align="center">用一个字节存储的布尔类型（True或False）</td> 
   <td align="center">‘b’</td> 
  </tr> 
  <tr> 
   <td align="center">np.int8</td> 
   <td align="center">一个字节大小，-128 至 127</td> 
   <td align="center">‘i’</td> 
  </tr> 
  <tr> 
   <td align="center">np.int16</td> 
   <td align="center">整数，-32768 至 32767</td> 
   <td align="center">‘i2’</td> 
  </tr> 
  <tr> 
   <td align="center">np.int32</td> 
   <td align="center">整数，-2 <strong>31 至 2</strong> 32 -1</td> 
   <td align="center">‘i4’</td> 
  </tr> 
  <tr> 
   <td align="center">np.int64</td> 
   <td align="center">整数，-2 <strong>63 至 2</strong> 63 - 1</td> 
   <td align="center">‘i8’</td> 
  </tr> 
  <tr> 
   <td align="center">np.uint8</td> 
   <td align="center">无符号整数，0 至 255</td> 
   <td align="center">‘u’</td> 
  </tr> 
  <tr> 
   <td align="center">np.uint16</td> 
   <td align="center">无符号整数，0 至 65535</td> 
   <td align="center">‘u2’</td> 
  </tr> 
  <tr> 
   <td align="center">np.uint32</td> 
   <td align="center">无符号整数，0 至 2 ** 32 - 1</td> 
   <td align="center">‘u4’</td> 
  </tr> 
  <tr> 
   <td align="center">np.uint64</td> 
   <td align="center">无符号整数，0 至 2 ** 64 - 1</td> 
   <td align="center">‘u8’</td> 
  </tr> 
  <tr> 
   <td align="center">np.float16</td> 
   <td align="center">半精度浮点数：16位，正负号1位，指数5位，精度10位</td> 
   <td align="center">‘f2’</td> 
  </tr> 
  <tr> 
   <td align="center">np.float32</td> 
   <td align="center">单精度浮点数：32位，正负号1位，指数8位，精度23位</td> 
   <td align="center">‘f4’</td> 
  </tr> 
  <tr> 
   <td align="center">np.float64</td> 
   <td align="center">双精度浮点数：64位，正负号1位，指数11位，精度52位</td> 
   <td align="center">‘f8’</td> 
  </tr> 
  <tr> 
   <td align="center">np.complex64</td> 
   <td align="center">复数，分别用两个32位浮点数表示实部和虚部</td> 
   <td align="center">‘c8’</td> 
  </tr> 
  <tr> 
   <td align="center">np.complex128</td> 
   <td align="center">复数，分别用两个64位浮点数表示实部和虚部</td> 
   <td align="center">‘c16’</td> 
  </tr> 
  <tr> 
   <td align="center">np.object_</td> 
   <td align="center">python对象</td> 
   <td align="center">‘O’</td> 
  </tr> 
  <tr> 
   <td align="center">np.string_</td> 
   <td align="center">字符串</td> 
   <td align="center">‘S’</td> 
  </tr> 
  <tr> 
   <td align="center">np.unicode_</td> 
   <td align="center">unicode类型</td> 
   <td align="center">‘U’</td> 
  </tr> 
 </tbody> 
</table>

## 二. 基本操作 ##

### 2.1 生成0和1的数组zeros，ones ###

1.  生成0的数组

np.zeros(shape[, dtype, order])#里面输入维度

![在这里插入图片描述][20210620210144455.png]

1.  生成1的数组

np.ones(shape[, dtype, order])

![在这里插入图片描述][2021062021015921.png]

### 2.2 转化现有的数组 array和asarray ###

1.  创建新的索引

array=np.array(ones)
    array

array([[1., 1., 1.],
           [1., 1., 1.]])

1.  引用之前数组

asarray=np.asarray(ones)
    asarray

array([[1., 1., 1.],
           [1., 1., 1.]])

1.  测试

ones[1]=2
    array,asarray

(array([[1., 1., 1.],
            [1., 1., 1.]]),
     array([[1., 1., 1.],
            [2., 2., 2.]]))

**总结**：`array`是创建一个**新的索引**，`asarray`是引用**之前的数组**，原来的**改变了**他也得**改变**

array([[1., 1., 1.],
           [1., 1., 1.]])

### 2.3 生成固定范围的数组 linspace ###

生成等间隔的序列：

np.linspace (start, stop, num, endpoint)

> `start` 序列的起始值  
> `stop` 序列的终止值，  
> `num` 要生成的等间隔样例数量，默认为50  
> `endpoint` 序列中是否包含stop值，默认为ture

列：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70]

### 2.4 生成随机数组 random ###

#### 2.4.1 rand() ####

返回\[0.0，1.0)内的一组均匀分布的数。

np.random.rand(d0, d1, ..., dn)

> d0是一维，d1是二维

列：

rand=np.random.rand(2)
    print(rand)
    print()
    rand_1=np.random.rand(1,2)
    print(rand_1)

[0.20820084 0.42793728]
    
    [[0.17072535 0.54934689]]

#### 2.4.2 uniform() ####

1.  功能：从一个均匀分布\[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.

np.random.uniform(low=0.0, high=1.0, size=None)

1.  参数介绍:

(1)`low`: 采样下界，float类型，默认值为0；

(2)`high`: 采样上界，float类型，默认值为1；

(3)`size`: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出mnk个样本，缺省时输出1个值。

#左闭右开，可以包含low不能包含high
    uniform=np.random.uniform(-1,1,5)#随机生成-1<=x<1的5个数
    uniform

array([ 0.1210682 , -0.57715686,  0.13236878,  0.25356491,  0.23658474])

#### 2.4.3 randint() ####

1.  **定义**：从一个均匀分布中随机采样，生成一个**整数**或**N维整数数组**

np.random.randint(low, high=None, size=None, dtype='l')

1.  **取数范围**：若`high`不为`None`时，取`[low,high)`之间随机整数，否则取值`[0,low)`之间随机整数。

列：

randint=np.random.randint(-1,1,5)#生成的是整数
    randint

array([ 0,  0, -1, -1,  0])

1.  可以用画布看一下

import matplotlib.pyplot as plt
    
    #生成随机数
    uniform=np.random.uniform(-1,1,5)#随机生成-1<=x<1的5个数
    randint=np.random.randint(-1,1,5)#生成的是整数
    
    #创建画布
    plt.figure(figsize=(10,10),dpi=100)
    #绘制折线图
    plt.hist(x=randint,bins=10)
    
    #显示图像
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70 1]

## 三. 正态分布创建方式 ##

> 正态分布是一种概率分布。正态分布是具有两个参数μ和σ的连续型随机变量的分布，第一参数μ是服从正态分布的随机变量的均值，第二个参数σ是此随机变量的方差，所以正态分布记作N(μ，σ )。

np.random.normal(loc=0.0, scale=1.0, size=None)

> `loc：float`
> 
>  此概率分布的均值（对应着整个分布的中心centre）
> 
> `scale：float`
> 
>  此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）
> 
> `size：int or tuple of ints`
> 
>  输出的shape，默认为None，只输出一个值

代码：

![在这里插入图片描述][20210620214448621.png]

#我们弄个图来看看就知道了
    normal=np.random.normal(0,1,1000000)#生成随机数
    plt.figure(figsize=(20,10),dpi=100)
    plt.hist(normal,1000)
    plt.show()
    #数据样本越多越平滑

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70 2]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70 3]

## 四. 数组的索引和切片 ##

#随机生成0~1内的一个二维数组
    x=np.random.rand(3,4)
    x

array([[0.49210879, 0.53267771, 0.31260445, 0.10365951],
           [0.95440635, 0.79749711, 0.83076363, 0.45117356],
           [0.58863855, 0.38651589, 0.32089043, 0.80523703]])

#获取第一列前两个数
    x[0,0:2]

array([0.49210879, 0.53267771])

#来看看三维的
    x1=np.random.rand(2,3,4)#创建一个三行四列的三维数组
    x1

array([[[0.2535971 , 0.78289806, 0.19668332, 0.33726196],
            [0.71314755, 0.6701532 , 0.00122882, 0.34245938],
            [0.84117058, 0.51255648, 0.9877622 , 0.77474966]],
    
           [[0.71203189, 0.09165988, 0.03920414, 0.20560316],
            [0.69056241, 0.35672482, 0.61398699, 0.28555582],
            [0.23272967, 0.03492783, 0.54847214, 0.07739248]]])

#获取第一个二行四列的数
    x1[0,1,3]

0.342459375072406

### 4.1 形状修改 reshape 和 T ###

#创建一个二维数组
    rand=np.random.rand(2,3)
    rand

array([[0.76541987, 0.02147122, 0.37629224],
           [0.11469583, 0.5610669 , 0.65114404]])

#修改rand为3行2列
    rand.reshape([3,2])

array([[0.76541987, 0.02147122],
           [0.37629224, 0.11469583],
           [0.5610669 , 0.65114404]])

#可以将行设置为-1，表示待机算，就是随便取什么值都行
    rand.reshape([-1,2])

array([[0.76541987, 0.02147122],
           [0.37629224, 0.11469583],
           [0.5610669 , 0.65114404]])

#数组的转置
    print(rand.shape)
    print(rand.T.shape)

(2, 3)
    (3, 2)

### 4.2 类型修改 astype ###

rand.tostring()

b' B4\xcfQ~\xe8?`7tE\x8d\xfc\x95?\xa6\x84V\t,\x15\xd8?\x08\xff\xd9\xa7\xb4\\\xbd?\t\xa3V\x94B\xf4\xe1?\xb1.\xca\x07,\xd6\xe4?'

rand.astype(np.float32)

array([[0.76541984, 0.02147122, 0.37629223],
           [0.11469582, 0.5610669 , 0.651144  ]], dtype=float32)

### 4.3 数组去重 unique ###

temp=np.array([[1,2,3],[1,3,4]])
    np.unique(temp)

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

## 五. ndarray运算 ##

### 5.1 逻辑运算 ###

# 重新生成8只股票10个交易日的涨跌幅数据
    stock_change=np.random.normal(0,1,(8,10))
    stock_change=stock_change[0:5,0:5]#取前五行，和前五列个数
    stock_change

array([[-1.52755746, -2.62057116,  0.592167  , -0.21291779,  2.32848585],
           [ 0.07585879, -1.31915832,  0.17912436,  1.36065436, -0.59037947],
           [ 0.12463083, -1.20308184, -0.75948532,  0.94894654, -0.75995878],
           [-2.01017904,  0.99691299,  0.02376165, -0.27839167,  0.0081121 ],
           [-3.51140042, -0.37608421,  1.62691763,  2.29858084,  1.71294573]])

# 逻辑判断, 如果涨跌幅大于0.5就标记为True 否则为False
    stock_change>0.5

array([[False, False,  True, False,  True],
           [False, False, False,  True, False],
           [False, False, False,  True, False],
           [False,  True, False, False, False],
           [False, False,  True,  True,  True]])

#将大于0.5的设置为1
    # BOOL赋值, 将满足条件的设置为指定的值-布尔索引
    stock_change[stock_change > 0.5] = 1
    stock_change

array([[-1.52755746, -2.62057116,  1.        , -0.21291779,  1.        ],
           [ 0.07585879, -1.31915832,  0.17912436,  1.        , -0.59037947],
           [ 0.12463083, -1.20308184, -0.75948532,  1.        , -0.75995878],
           [-2.01017904,  1.        ,  0.02376165, -0.27839167,  0.0081121 ],
           [-3.51140042, -0.37608421,  1.        ,  1.        ,  1.        ]])

### 5.2 通用判断函数 np.all()相当于and ,np.any() 相当于or ###

# 判断stock_change[0:2, 0:5]是否全是上涨的,就是是否全部大于0
    np.all(stock_change[0:2,0:5]>0)

False

# # 判断前5只股票这段期间是否有上涨的
    np.any(stock_change[0:5, :] > 0 )

True

### 5.3 np.where（三元运算符） ###

## 判断前四个股票前四天的涨跌幅 大于0的置为1，否则为0
    temp=stock_change[:4,:4]
    temp
    np.where(temp>0,1,0)#大于零就设置为1，小于就设置为0

array([[0, 0, 1, 0],
           [1, 0, 1, 1],
           [1, 0, 0, 1],
           [0, 1, 1, 0]])

# 判断前四个股票前四天的涨跌幅 大于0.5并且小于1的，换为1，否则为0
    # 判断前四个股票前四天的涨跌幅 大于0.5或者小于-0.5的，换为1，否则为0
    np.where(np.logical_and(temp > 0.5, temp < 1), 1, 0)
    np.where(np.logical_or(temp > 0.5, temp < -0.5), 1, 0)

array([[1, 1, 1, 0],
           [0, 1, 0, 1],
           [0, 1, 1, 1],
           [1, 1, 0, 0]])

### 5.4 统计运算案列：股票涨跌幅 ###

> 进行统计的时候，axis 轴的取值并不一定，Numpy中不同的API轴的值都不一样，在这里，axis 0代表列, axis  
> 1代表行去进行统计

`max`:最大值  
`std`:标准差  
`min`:最小值  
`mean` :平均值  
`argmax`：最大下标  
`argmin`：最小值的下标

stock_change=np.random.normal(0,1,(8,10))
    stock_change
    temp=stock_change[:4,:4]
    temp

array([[-0.40505247,  0.92951889,  2.011763  , -0.53131927],
           [ 0.0192382 ,  0.99129611,  1.25257476,  1.11735188],
           [-0.82399859,  1.23058116, -0.7239252 , -0.75130107],
           [-0.34716124,  0.22839569, -0.75585576,  0.33319753]])

# 接下来对于这4只股票的4天数据，进行一些统计运算
    # 指定行 去统计
    print("前四只股票前四天的最大涨幅{}".format(np.max(temp, axis=1)))
    #指定列
    print("前四只股票前四天的最大涨幅{}".format(np.max(temp, axis=0)))

前四只股票前四天的最大涨幅[2.011763   1.25257476 1.23058116 0.33319753]
    前四只股票前四天的最大涨幅[0.0192382  1.23058116 2.011763   1.11735188]

print("前四只股票前四天的波动程度{}".format(np.std(temp, axis=1)))

前四只股票前四天的波动程度[1.04314994 0.48568966 0.86549477 0.44208006]

# 获取股票指定哪一天的涨幅最大,
    print("前四只股票前四天内涨幅最大{}".format(np.argmax(temp, axis=1)))
    print("前四天一天内涨幅最大的股票{}".format(np.argmax(temp, axis=0)))

前四只股票前四天内涨幅最大[2 2 1 3]
    前四天一天内涨幅最大的股票[1 2 0 1]

print("前四只股票前四天内涨幅最小{}".format(np.argmin(temp, axis=1)))

前四只股票前四天内涨幅最小[3 0 0 2]

## 六. 数组间的运算 ##

arr=np.random.rand(1,3)
    arr

array([[0.57502302, 0.71786717, 0.54316827]])

arr*3#每个乘3

array([[1.72506907, 2.15360151, 1.6295048 ]])

# 可以对比python列表的运算，看出区别#
    a = [1, 2, 3, 4, 5]
    a*3#列表加长了三倍

[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

### 6.1 广播机制 ###

1.  执行 `broadcast` 的前提在于，两个 `ndarray` 执行的是 `element-wise`的运算，Broadcast机制的功能是为了方便**不同形状**的ndarray（numpy库的核心数据结构）进行**数学运算**。
2.  运算要求：  
    （1）维度相等  
    （2）`shape`（其中相对应的一个地方为1）

#列数为1，且行数相等，或行数为一都行
    arr1 = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]])
    arr2 = np.array([[1], [3]])
    arr1+arr2

array([[2, 3, 4, 3, 2, 5],
           [8, 9, 4, 5, 6, 4]])

#shape要相等，不如下面维度和上面的不一样就报错
    arr2 = np.array([[1], [3],[2]])
    arr1+arr2

ValueError: operands could not be broadcast together with shapes (2,6) (3,1)

### 6.2 矩阵运算 matmul 和 dot ###

随机生成int类型的数

![在这里插入图片描述][20210621203737241.png]

变换形状，具体可以看上面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70 4]

开始测试  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70 5]

> 区别：np.matmul中禁止矩阵与标量的乘法。 在矢量乘矢量的內积运算中，np.matmul与np.dot没有区别。

> 本人csdn博客：[https://blog.csdn.net/weixin\_46654114][https_blog.csdn.net_weixin_46654114]  
> 转载说明：跟我说明，务必注明来源，附带本人博客连接。

请给我点个赞鼓励我吧  
![在这里插入图片描述][20200507113619405.png_pic_center]

[20210620205814934.png]: /images/20221022/96fd65e8edb54d55a67b49fc5ebd88fb.png
[20210620205958465.png]: /images/20221022/55e4217dcada4f5fb0c3786cb2b9556f.png
[20210620210115535.png]: /images/20221022/2c2e97a17e6640898ba822549900c8a9.png
[20210620210144455.png]: /images/20221022/267476743a03468c8c80b5380177ac5b.png
[2021062021015921.png]: /images/20221022/98884ec4edfd4c51980fd73d2f0b6db5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70]: /images/20221022/95c6b57374b14ac9a3bbcc82da57bfc9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70 1]: /images/20221022/820a8680df1042968910369b1820713e.png
[20210620214448621.png]: /images/20221022/320820a03619482c9096547fda3b24f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70 2]: /images/20221022/a0d320a0724e48d38046e86966be8a1b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70 3]: /images/20221022/db5dd6de55334d7eba424064ba946e58.png
[20210621203737241.png]: /images/20221022/ce9180622c4342cd8354260b0f4d5cc0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70 4]: /images/20221022/2ce6cfab4db74192874d98ca42ca4704.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjY1NDExNA_size_16_color_FFFFFF_t_70 5]: /images/20221022/14eeabc2464142cb87bad4a351bb4bec.png
[https_blog.csdn.net_weixin_46654114]: https://blog.csdn.net/weixin_46654114
[20200507113619405.png_pic_center]: /images/20221022/f9b242957a7e4537a579997b59b4c985.png