NumPy（一）基础

淩亂°似流年 2022-06-02 06:46 347阅读 0赞

NumPy（Numerical Python的缩写）是一个开源的Python科学计算库。使用NumPy，就可以很自然地使用数组和矩阵。NumPy包含很多实用的数学函数，涵盖线性代数运算、傅里叶变换和随机数生成等功能。

NumPy数组在数值运算方面的效率优于Python提供的list容器。使用NumPy可以在代码中省去很多循环语句，因此其代码比等价的Python代码更为简洁。

NumPy数组一般是同质的（但有一种特殊的数组类型例外，它是异质的），即数组中的所有元素类型必须是一致的。这样有一个好处：如果我们知道数组中的元素均为同一类型，该数组所需的存储空间就很容易确定下来。

**1、Numpy数组对象**

创建数组：arange()创建一维数组；array()创建一维或多维数组，其参数是类似于数组的对象，如列表等

from numpy import *
    a=arange(5)
    print a.dtype
    print a.shape
    print a
    b=array([0,1,2,3,4])
    print b.dtype
    print b.shape
    print b

这是一个包含5个元素的向量，取值分别为0~4的整数。数组的shape属性返回一个元组（tuple），元组中的元素即为NumPy数组每一个维度上的大小。上面例子中的数组  
是一维的，因此元组中只有一个元素。

**2、创建多维数组**

m=array([arange(2),arange(2)])
    print m.shape
    print m

将arange函数创建的数组作为列表元素，把这个列表作为参数传给array函数，从而创建了一个2×2的数组。  
**array函数**可以依据给定的对象生成数组。给定的 对象应是类数组，如Python中的 列表。

aa=array([[1,2],[3,4]])
    print aa
    print aa[0,1]

array函数传递的对象是一个嵌套的列表。  
取该数组中的元素，数组的下标是从0开始的。

**3、Numpy数据类型**

bool 用一位存储的布尔类型（值为TRUE或FALSE）
    inti 由所在平台决定其精度的整数（一般为int32或int64）
    int8 整数，范围为128至127
    int16 整数，范围为32 768至32 767
    int32 整数，范围为231至231 1
    int64 整数，范围为263至263 1
    uint8 无符号整数，范围为0至255
    uint16 无符号整数，范围为0至65 535
    uint32 无符号整数，范围为0至2321
    uint64 无符号整数，范围为0至2641
    float16 半精度浮点数（16位）：其中用1位表示正负号，5位表示指数，10位表示尾数
    float32 单精度浮点数（32位）：其中用1位表示正负号，8位表示指数，23位表示尾数
    float64或float 双精度浮点数（64位）：其中用1位表示正负号，11位表示指数，52位表示尾数
    complex64 复数，分别用两个32位浮点数表示实部和虚部
    complex128或complex 复数，分别用两个64位浮点数表示实部和虚部

每一种数据类型均有对应的类型转换函数：float(42)->42.0  
在NumPy中，许多函数的参数中可以指定 **数据类型**，通常这个 **参数是可选**的：

a=arange(6,dtype=float)
    print a

需要注意的是，复数是不能转换为整数的，这将触发TypeError错误,同样，复数也不能转换为浮点数。不过，浮点数却可以转换为复数，例如complex(1.0)。注意，  
有j的部分为复数的虚部。

**4、数据类型**

数据类型对象是numpy.dtype类的实例,NumPy数组是有数据类型的，更确切地说，NumPy数组中的每一个元素均为相同的数据类型。数据类型对象可以给出单个数组元素在  
内存中占用的字节数，即dtype类的itemsize属性：

a=arange(6,dtype=float32)
    print a
    print a.dtype.itemsize

**5、字符编码**

NumPy可以使用字符编码来表示数据类型，这是为了 **兼容NumPy的前身Numeric。**

整数 i
    无符号整数 u
    单精度浮点数 f
    双精度浮点数 d
    布尔值 b
    复数 D
    字符串 S
    unicode字符串 U
    void （空） V

b=array(3,dtype='d')
    print b.dtype
    print b

**6、自定义数据类型**

fl=dtype(float)
    print fl
    In=dtype(uint16)
    print In
    bl=dtype(bool)
    print bl
    
    #f1代替float
    a=arange(8,dtype=fl)
    print a
    b=arange(2,dtype=In)
    print b

还可以将两个字符作为参数传给数据类型的构造函数。此时，第一个字符表示数据类型，第二个字符表示该类型在内存中占用的字节数（2、4、8分别代表精度为16、32、64位的浮点数）：

a=arange(8,dtype='f8')
    print a
    print a.dtype
    a1=arange(8,dtype='f2')
    print a1
    print a1.dtype

**7、dtype 类的属性**

获取数据类型的字符编码：

a=dtype('float32')
    print a.char

type属性对应于数组元素的数据类型：

a=dtype('float32')
    print a.char
    print a.type

字节序是指位长为32或64的字（word）存储的顺序，包括大端序（big-endian）和小端序（little-endian）。 **大端序**是将最高位字节存储在最低的内存地址处，用>表示；与之相反， **小端序**是将 **最低位**字节存储在最低的内存地址处，用 <表示：

a=dtype('float32')
    print a.char
    print a.type
    print a.str

**8、一维数组的索引和切片**

a=arange(9)
    #s索引
    print a[3:6]
    #步长选取元素
    print a[:6:2]
    #翻转数组
    print a[::-1]

**9、多维数组的切片和索引**

# 2×3×4的三维数组
    # 可以形象地把它看做一个两层楼建筑，每层楼有12个房间，并排列成3行4列。
    b=arange(24).reshape(2,3,4)
    print b
    #可以用三维坐标来选定任意一个房间，即楼层、行号和列号
    print b[1,2,3]
    #不关心楼层，也就是说要选取所有楼层的第m行、第n列的房间
    print b[:,2,3]
    #选取第1层楼的所有房间：
    print b[0,:,:]
    #多个冒号可以用一个省略号（...）来代替
    print b[0,...]
    #选取第m层楼、第n排的所有房间
    print b[1,2]
    #数组切片中间隔地选定元素：
    print b[0,1,::2]
    #不指定楼层和行号
    print b[...,2]
    #选取所有位于第i行的房间，而不指定楼层和列号：
    print  b[:,2]
    #选取第1层楼的所有位于第2列的房间，在对应的两个维度上指定即可：
    print b[0,:,1]
    #X要选取第1层楼的最后一列的所有房间
    print b[0,:,-1]
    #要反向选取第1层楼的最后一列的所有房间
    print b[0,::-1,-1]

**10、改变数组维度**

(1) ravel 用ravel函数完成展平的操作：

(2) flatten 这个函数恰如其名，flatten就是展平的意思，与ravel函数的功能相同。

(3) 用元组设置维度 除了可以使用reshape函数，我们也可以直接用一个正整数元组来设置数组的维度

(4) transpose 在线性代数中，转置矩阵是很常见的操作。

(5) resize resize和reshape函数的功能一样，但resize会直接修改所操作的数组

a=arange(24).reshape(2,3,4)
    print a
    print a.ravel()
    print a.flatten()
    
    a.shape=(6,4)
    print a
    print a.transpose()
    
    a.resize((2,12))
    print a

**11、组合数组**

用了vstack、dstack、hstack、column\_stack、row\_stack以及concatenate函数

(1) 水平组合

(2) 垂直组合，构造一个元组作为参数

(3) 深度组合，将一系列数组沿着纵轴（深度）方向进行层叠组合

(4) 列组合

(5) 行组合

a=arange(9).reshape(3,3)
    print a
    b=2*a
    print b
    # (1) 水平组合
    print hstack((a,b))
    print concatenate((a,b),axis=1)
    # (2) 垂直组合
    print vstack((a,b))
    print concatenate((a,b),axis=0)
    # (3) 深度组合
    print dstack((a,b))
    # (4) 列组合
    #数对于一维数组将按列方向进行组合
    c=array([0,1,2,3,4,5])
    d=3*c
    print column_stack((c,d))
    #二维数组，column_stack与hstack的效果是相同的
    print column_stack((a,b))
    # (5) 行组合
    # 有按行方向进行组合的函数，它就是row_stack
    #对于两个一维数组，将直接层叠起来组合成一个二维数组。
    print row_stack((c,d))
    # 对于二维数组，row_stack与vstack的效果是相同的
    print row_stack((a,b))

**12、分割数组**

用hsplit、vsplit、dsplit和split函数进行了分割数组的操作。

(1) 水平分割

(2) 垂直分割

(3) 深度分割

a=arange(9).reshape(3,3)
    # 水平分割,分割为3个相同大小的子数组
    print hsplit(a,3)
    #调用split函数并在参数中指定参数axis=1
    print split(a,3,axis=1)
    #垂直分割 vsplit函数将把数组沿着垂直方向分割
    print vsplit(a,3)
    # 深度分割
    c=arange(27).reshape(3,3,3)
    print dsplit(c,3)

**13、数组属性**

除了shape和dtype属性以外，数组对象还有很多其他的属性

ndim属性，给出数组的维数，或数组轴的个数

size属性，给出数组元素的总个数

itemsize属性，给出数组中的元素在内存中所占的字节数

nbytes属性来查看整个数组所占的存储空间，这个属性的值其实就是itemsize和size属性值的乘积

T属性的效果和transpose函数一样

对于一维数组，其T属性就是原数组

NumPy中，复数的虚部是用j表示的

real属性，给出复数数组的实部。如果数组中只包含实数元素，则其real属性将输出原数组

imag属性，给出复数数组的虚部

flat属性将返回一个numpy.flatiter对象，这是获得flatiter对象的唯一方式——我们无法访问flatiter的构造函数。这个所谓的“扁平迭代器”可以让我们像遍历一维数  
组一样去遍历任意的多维数组

**14、数组转换**

(1) 转换成列表

(2) astype函数可以在转换数组时指定数据类型

b=array([1,2,3,4,5,6])
    print b
    print b.tolist()
    print b.astype(float)
    #将复数转换为整数的过程中，丢失了复数的虚部
    c=array([ 1.+1.j, 3.+2.j])
    print c.astype(int)

**15、数组和列表**

#数组
    a=arange(5)
    #列表
    b=[]
    for i in range(5):
        b.append(i)
    print a
    print b

[0 1 2 3 4] 数组
    [0, 1, 2, 3, 4]列表

两者最明显的区别元素之间是否有分隔符‘，’有则是列表，无则是数组