【python】 Numpy介绍与使用

忘是亡心i 2022-04-06 05:56 250阅读 0赞

# 0 前言    #

一维数据一般采用线性方式表示，可以是有序或者无序的。  
列表和数组都可以表示一组数据的有序结构，但是列表元素类型可以不同，数组元素类型需要相同。

列表元素数据类型可以不同:

> \[“1”,“2”,“str”,“4”,“pi”\]

**数组数据类型要相同。**

二维数据是一维数据的多个组合形式。表格是典型的二维数据。

多维数据由一维或二位在新的维度上组合，如时间维度。比如去年的表格和今年的表格存在时间维度的差别。

高维数据：一般由**键值对**将数据组织表示出来。

> \{
> 
> “姓名”:“lol”,
> 
> “年龄”:“18”,
> 
> “学习经历”:\{
> 
>      “小学”:“xx小学”,
> 
>      “中学”:“xx中学”,
> 
>      “大学”:“xx大学”
> 
>      \},
> 
> \}

python中数据的表示形式：

一维：列表 \[有序\] 和集合 \{无序\} 类型。  
二维、多维数据多用列表\[ \]类型表示。

[ [0, 1, 2],
      [3, 4, 5] 
    ]
     #二维数据，形状（2,3）

三维数据,数据形状（2,3,4）

[ [ [ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11] ],
        
      [ [12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23] ]
    ]

高维数据：字典 \{ \} 或其他数据表示格式（json，xml等）。

# 1 numpy数据类型ndarray介绍 #

开源python科学计算基础库，可以进行快速的数组运算。降低传统数组运算时循环需要的时间，节省运算和存储空间。  
数组类型为ndarray 对象。  
使用前先安装：

> pip install numpy

一般引用方法：

> import numpy as np  
> np是别名可以自己设置，为了节省代码量增加可读性一般最好和大家统一

## 1.1array数组介绍及基本属性 ##

ndarray数据类型不仅包含实际的数据，还有描述数据的一些详细信息，如数据类型，维度，结构等等。  
ndarray(shape, dtype=float, buffer=None, offset=0,strides=None, order=None)

> shape:tuple of ints,Shape of created array.为元组型数值，表示创建的array形状。  
> dtype=float：data-type, optional，创建的numpy数组的数据类型，可选参数。  
> buffer：object exposing buffer interface, optional，数据接口，可以在创建array时填充数据  
> offset：Offset of array data in buffer.填充数据的偏移。  
> strides：Strides of data in memory.  
> order：数据排布格式，行形式或者列形式， \{‘C’, ‘F’\}, optional

在numpy程序中ndarray就是array。  
array数组的轴（axis）：数据的维度  
秩（rank）：表示数据维度的数量。  
array对象的常用属性：

<table> 
 <thead> 
  <tr> 
   <th align="left">属性</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">.T</td> 
   <td>Transpose of the array.数组的转置</td> 
  </tr> 
  <tr> 
   <td align="left">.ndim</td> 
   <td>秩，多维数组维度的值</td> 
  </tr> 
  <tr> 
   <td align="left">.shape</td> 
   <td>对象的度量尺度，如（m，n）表示矩阵m行n列</td> 
  </tr> 
  <tr> 
   <td align="left">.size</td> 
   <td>array对象中元素的个数相当于shape中的乘积</td> 
  </tr> 
  <tr> 
   <td align="left">.dtype</td> 
   <td>array对象的元素类型，可设置</td> 
  </tr> 
  <tr> 
   <td align="left">.itemsize</td> 
   <td>数组对象中每个元素的大小，以字节为单位，如dtype=int32型表示4字节</td> 
  </tr> 
 </tbody> 
</table>

示例：

import numpy as np
    a = ([2,5,3,8],[1,4,7,6])
    b = np.arange(24).reshape((2,3,4))
    
    print(a) #此处a是tuple（）类型
    ([2, 5, 3, 8], [1, 4, 7, 6])
    
    a = np.array(a)
    print(a) #这里a才是numpy的array类型
    [[2 5 3 8]
     [1 4 7 6]]
    
    print(b) #b是三维的数据
    [	[[ 0  1  2  3]
      	 [ 4  5  6  7]
      	 [ 8  9 10 11]]
    
     	[[12 13 14 15]
      	 [16 17 18 19]
      	 [20 21 22 23]]	]

常用属性：

a = np.array([[1,2,4],[2,3,6]])
    
    a
    Out[3]: 
    array([[1, 2, 4],
           [2, 3, 6]])
    
    a.T  #转置
    Out[4]: 
    array([[1, 2],
           [2, 3],
           [4, 6]])
    
    a.ndim  #维度
    Out[5]: 2
    
    a.shape  #形状，返回元组
    Out[6]: (2, 3)
    
    a.size  #数据量
    Out[7]: 6
    
    a.dtype  #数据类型
    Out[8]: dtype('int32')
    
    a.itemsize   #单个数据占用大小
    Out[9]: 4

你可以在IPython编辑区内对变量或者函数输入 **函数/变量？** 查看其详细属性。np.ndarray？ 可以查看ndarray数组的详细属性。a？查看变量的属性。

> a?  
> Type: ndarray  
> String form:  
> \[\[2 5 3 8\]  
> \[1 4 7 6\]\]  
> Length: 2  
> File: d:\\pyrelated\\anaconda\\lib\\site-packages\\numpy\_*init*\_.py  
> … … … .

使用array创建的数组元素默认是float型，可以进行更改。

## 1.2 array数组中的数据类型 ##

array数组在创建时有个参数dtype是可以设置的，默认的是float，可能会根据数据量自动调整具体类型，numpy里面的数据类型非常的详细，是为了合理使用存储空间空间、评估程序规模提高程序运行速度等。  
数据类型有：

> bool, intc, intp, int8, int16, int32, int64, uint8, uint16, uint32, uint64,float16, float32, float64, complex64, complex128 复数 img + real

## 1.3 创建array数组 ##

（1）利用python中的列表\[\]和元组()创建ndarray数组。x = np.array(lis/tuple)

a = [[1,2],[3,4]]  #列表
    b = ([5,6],[7,8])  #元组
    
    type(a)
    Out[19]: list
    type(b)
    Out[20]: tuple
    
    c = np.array(a)  #转化为array数组
    d = np.array(b)
    
    c
    Out[23]: 
    array([[1, 2],
           [3, 4]])
    d
    Out[24]: 
    array([[5, 6],
           [7, 8]])

创建时数据类型还可以指定，之前介绍过array（）的一些参数。不指定类型的时候可以根据数据情况自动关联一个dtype类型。

e = np.array(a,dtype=np.int64)  #自定义数据类型
    
    d.dtype
    Out[27]: dtype('int32')
    e.dtype
    Out[28]: dtype('int64')

（2）使用numpy中的函数创建ndarray数组。

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">arange(n)</td> 
   <td>生成0-n-1数值的ndarray</td> 
  </tr> 
  <tr> 
   <td align="left">ones(shape)</td> 
   <td>生成一个全是1的形状为shape的数组</td> 
  </tr> 
  <tr> 
   <td align="left">zeros(shape)</td> 
   <td>生成全是0的，shape是表示大小的元组（）</td> 
  </tr> 
  <tr> 
   <td align="left">full(shape,val)</td> 
   <td>生成一个大小是shape，值是val的数组</td> 
  </tr> 
  <tr> 
   <td align="left">eye(n)</td> 
   <td>生成正方形n的单位矩阵</td> 
  </tr> 
  <tr> 
   <td align="left">ones_like(a)</td> 
   <td>根据数组a的形状生成全是1的</td> 
  </tr> 
  <tr> 
   <td align="left">zeros_like(a)</td> 
   <td>根据a生成全是0的</td> 
  </tr> 
  <tr> 
   <td align="left">full_like(a,val)</td> 
   <td>根据a的声称全是值val的数组</td> 
  </tr> 
 </tbody> 
</table>

示例：

a = np.arange(4)   #一维数组
    b = np.ones((2,2))  #全1数组
    c= np.zeros((2,3))    #全0数组
    d = np.full((3,3),6)   #使用定值生成数组
    e = np.eye(4)    #单位矩阵
    
    a
    Out[39]: array([0, 1, 2, 3])
    b
    Out[40]: 
    array([[ 1.,  1.],
           [ 1.,  1.]])
    c
    Out[41]: 
    array([[ 0.,  0.,  0.],
           [ 0.,  0.,  0.]])
    d
    Out[42]: 
    array([[6, 6, 6],
           [6, 6, 6],
           [6, 6, 6]])
    e
    Out[43]: 
    array([[ 1.,  0.,  0.,  0.],
           [ 0.,  1.,  0.,  0.],
           [ 0.,  0.,  1.,  0.],
           [ 0.,  0.,  0.,  1.]])
    
    f = np.ones_like(d)  #以数组d的格式作为参考，生成新的值是1的数组
    g = np.zeros_like(d)
    h = np.full_like(d,8)
    
    f
    Out[51]: 
    array([[1, 1, 1],
           [1, 1, 1],
           [1, 1, 1]])
    g
    Out[52]: 
    array([[0, 0, 0],
           [0, 0, 0],
           [0, 0, 0]])
    h
    Out[53]: 
    array([[8, 8, 8],
           [8, 8, 8],
           [8, 8, 8]])

（3）其他函数创建。  
np.linspace(A,B,C) 在AB间均匀取C个数据，其他参数np.linspace？查看

np.linspace(2.0, 3.0,5)    #生成线性值
    Out[55]: array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])

np  
np.concatenate(a，b) 合并多个数组

a = np.linspace(2.0, 3.0,5)
    b = np.arange(4)
    c = np.concatenate((a,b))  #合并数组，其他参数help查看文档
    
    c
    Out[78]: array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ,  0.  ,  1.  ,  2.  ,  3.  ])

# 2 array 数组的变换 #

生成的array数组可以进行维度和元素类型的变换。

## 2.1 维度变换 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">常用方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">.reshape(shape)</td> 
   <td>不修改元素，新生成shape形状数组，原数组也不改变</td> 
  </tr> 
  <tr> 
   <td align="left">.resize(shape)</td> 
   <td>在原数组基础上直接修改shape形状</td> 
  </tr> 
  <tr> 
   <td align="left">.flatten()</td> 
   <td>降维处理，整理新生成一维数组</td> 
  </tr> 
 </tbody> 
</table>

a = np.arange(24).reshape((2,3,4))
    Out[127]: 
    array([[[ 0,  1,  2,  3],
            [ 4,  5,  6,  7],
            [ 8,  9, 10, 11]],
    
           [[12, 13, 14, 15],
            [16, 17, 18, 19],
            [20, 21, 22, 23]]])
    
    a.reshape((2,4,3))   #使用reshape时原来的数组a不会变化，会新生成一个
    Out[128]: 
    array([[[ 0,  1,  2],
            [ 3,  4,  5],
            [ 6,  7,  8],
            [ 9, 10, 11]],
    
           [[12, 13, 14],
            [15, 16, 17],
            [18, 19, 20],
            [21, 22, 23]]])
            
    a.resize((4,3,2))    #使用resize就会改变原来a的形状
    print(a)
    [[[ 0  1]
      [ 2  3]
      [ 4  5]]
    
     [[ 6  7]
      [ 8  9]
      [10 11]]
    
     [[12 13]
      [14 15]
      [16 17]]
    
     [[18 19]
      [20 21]
      [22 23]]]
      
    print(a.flatten())  #降维，平整为一维数据
    [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]

## 2.2 array数组类型的变换 ##

（1）array 的数据类型变化。  
设a为一个array数组。  
b = a.astype（newtype）  
使用a.astype（）的时候相当于新复制了一个数组，然后进行改变。

a = np.arange(5)
    
    a.dtype
    Out[134]: dtype('int32')
    
    a.astype(np.float)
    Out[135]: array([ 0.,  1.,  2.,  3.,  4.])

（2）array 数组转为列表  
转化为列表会比numpy数组慢很多，除非有特殊要求，不建议使用。

a
    array([[0, 1, 2],
           [3, 4, 5]])
    
    a.tolist()
    Out[138]: [[0, 1, 2], [3, 4, 5]]

# 3 numpy数组的索引和切片 #

索引：获取指定位置的数据元素  
切片：获取数据元素子集

## 3.1 一维索引切片： ##

直接通过 a\[x\]，a\[A:B:C\] 获取

array([0, 1, 2, 3])
    
    a[1]
    Out[141]: 1
    a[0:2:1]
    Out[142]: array([0, 1])

## 3.2 多维索引切片 ##

可以将多维数据的每一个维度按一维形式切片索引即可

array([[[ 0,  1,  2],
            [ 3,  4,  5],
            [ 6,  7,  8]],
    
           [[ 9, 10, 11],
            [12, 13, 14],
            [15, 16, 17]]])
    
    a[:,1,2]  #第一个维度取全部，第二个维度取第2个位置，第三个维度取第3个位置
    Out[4]: array([ 5, 14])
    
    array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 6,  7,  8],
           [ 9, 10, 11]])
    a[[1,2],[0,1]]  #先在第一个维度取2,3行，第二个维度取1,2列
    Out[7]: array([3, 7])

# 4 np.random 随机数生成函数 #

np.random.rand（）和np.random.randn（）使用类似，生成正态分布随机样本数组。

> （）里面没有参数时返回一个浮点数  
> （X）有一个参数时，返回秩是1，长度是X的数组  
> （2,3）两个参数时，表示对应形状的随机数组，和np.random.standard\_normal()功能一样，只不过它需要输入元组（（2,3））

rand（）生成的在0-1之间，randn（）没有限制数据样本区间。

np.random.randint（）生成随机整数。

> randint(low, high=None, size=None, dtype=‘l’)  
> 指定区间、数量、类型

np.random.random(size)只能生成随机数。

> size表示个数。