Python之数据分析（Numpy的使用、多维数组、数据类型）

落日映苍穹つ 2023-02-23 08:15 61阅读 0赞

### 文章目录 ###

*   *  写在前面
     *   *  一、数据分析与Numpy
         *  二、多维数组
         *  三、Numpy的数据类型

## 写在前面 ##

代码中的np表示的是numpy，因为导入的时候是：import numpy as np

### 一、数据分析与Numpy ###

**1、数据分析**  
MATLAB：专业化数据分析工具  
Numpy：更简单上手，且结合了MATLAB大部分功能

**2、Numpy介绍**

*  应用于数值分析领域的Python语言工具
 *  是一个开源的科学计算库
 *  弥补了作为通用编程语言的Python在数值计算方面能力弱、速度慢的不足
 *  拥有丰富的数学函数、强大的多位数组和优异的运算性能
 *  与Scipy、scikit、matplotlib等其他科学计算库可以很好协调
 *  可以取代matlab等工具，允许用户进行快速开发的同时完成交互式的原型设计

**3、Numpy的效率**  
![11][]  
可以清楚看到，使用Numpy计算的效率是普通python语句计算的近60倍，这里使用的是微秒（10的-6次方）

**4、练习代码**

import datetime as dt
    import numpy as np
    
    n = 100000
    start = dt.datetime.now()
    A, B = [], []  # 两个空列表
    for i in range(n):
        A.append(i ** 2)  # 计算i的平方
        B.append(i ** 3)  # 计算i的3次方
    C = []
    # 用zip拉链拉起来就可以同时遍历两个列表
    for a, b in zip(A, B):
        C.append(a + b)
    print("直接：", (dt.datetime.now() - start).microseconds)  # 输出直接用py语句来实现计算的运行时间
    
    # 使用Numpy来实现
    start = dt.datetime.now()
    C = np.arange(n) ** 2 + np.arange(n) ** 3
    print("Numpy：", (dt.datetime.now() - start).microseconds)

### 二、多维数组 ###

**1、多维数组**  
数组：空间上内存连续，元素同类型  
Numpy中的数组：是numpy.ndarray这个类实例化来的对象，用于表示数据结构中的  
任意维度的数组（ndarray表示数组名）

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

*  numpy.arange（起始，终止，步长）
 *  numpy.array：被解释为数组的容器
 *  ndarray.dtype属性：表示元素的数据类型，astype()方法可以修改元素类型（ndarray表示数组名）
 *  ndarray.shape属性：表示数组的维度，reshapre()方法可以改变维数，如`b = np.arange(1, 25).reshape(2, 3, 4)`
 *  元素索引：数组\[页索引\]\[行索引\]\[列索引\]；数组\[页索引，行索引，列索引\]

**3、练习代码**

import numpy as np
    
    a = np.arange(1,10,2)
    print(a)
    
    # 一维数组里面放入一个列表
    b = np.array([2,4,6,8,10])
    print(b)
    # 二维数组里面放入两个一维列表
    c = np.array([[1,3,5,7,9],
                  [2,4,6,8,10]])
    print(c)
    
    d = np.array(['1','2','3'])
    
    # 查看数组类型，查看元素类型
    print(c.dtype)
    print(type(c))
    print(type(c[0][3]))
    print(type(d[1]))
    
    # 给数组指定类型
    e = np.array(['1','2','3'], dtype=np.int32)
    print(type(e[0]))
    f = e.astype(np.str)
    print(type(f[0]))
    
    # 查看数组的维度
    print(c.shape)
    # 创建一个2*3*4的数组，一个[]就是一个维度
    # 最内部arange()又代表一个维度，因此是三维
    g = np.array([
        [np.arange(1,5), np.arange(2,6), np.arange(3,7)],
        [np.arange(2,6), np.arange(7,11), np.arange(12,16)]
    ])
    print(g.shape)
    print(g.shape[0])  # 输出数组的页数，2*3*4，所以是2页
    print(g)
    
    # 遍历每个索引下的元素
    h = np.array([
        [
            [1,2],[3,4]
        ],
        [
            [5,6],[7,8]
        ]
    ])
    # shape[0]代表页数，1代表行数，2代表列数……以此类推
    for i in range(h.shape[0]):
        for j in range(h.shape[1]):
            for k in range(h.shape[2]):
                print(h[i,j,k])

### 三、Numpy的数据类型 ###

**1、numpy的内置类型**  
bool\_：1字节布尔型

int8：1字节，有符号整型（正负），-128~127  
int16：2字节，有符号整型（正负）  
uint8：1字节无符号整型，0~255  
uint64：8字节无符号整型

float16：2字节浮点型  
float64：8字节浮点型

complex64：8字节复数型  
complex128：16字节复数型

str\_：字符串型

**2、自定义类型**  
通过dtype将多个相同或者不同的numpy内置类型组合成某种复合类型  
除了使用内置类型的全称（后面的数字代表位数），还可以通过类型编码字符串（后面的数字代表字节数，1字节=8位）来简化类型的说明

*  numpy.int8——>i1
 *  numpy.nint32——>u4
 *  numpy.float64——>f8
 *  numpy.complex128——>c16
 *  numpy.str\_——>U字符数
 *  numpy.bool\_——>b

**3、字节序**  
对于多字节的整数可以加上 字节序 前缀：

<：小端字节序，低数位低地址，前高后低
    
    >：大端字节序，低数位高地址，前低后高
    =：处理器（CPU）系统默认

<：0x1234

>：0x1234

**4、练习代码**

import numpy as np
    
    a = np.array([('abc',[1,2,3,4,5])],dtype='U3, 5i4')
    # U3, 5i4表示一个新的类型，3个字符长度的字符串，5个4字节大小的int类型
    # 访问各个字符，用默认字段名f：['f0']，['f1']，['f2']……
    # print(a[0]['f0']) # 访问到abc
    # print(a[0]['f1']) # 访问到数字
    # print(a[0]['f0'][1]) # 访问b
    # print(a[0]['f1'][2]) # 访问3
    
    # 自定义 字段名：字段名，类型（全称），字符数/字节大小
    b = np.array([('abc',[1,2,3,4,5])],
                 dtype=[('ss', np.str, 3), ('ii', np.int, 5)])
    # 使用自定义字段名来访问
    # print(b[0]['ss']) # 访问到abc
    # print(b[0]['ii']) # 访问到数字
    # print(b[0]['ss'][1]) # 访问b
    # print(b[0]['ii'][2]) # 访问3
    
    # 第三种方式：既可以自定义字段名，又可以使用类型简称
    c = np.array([('abc',[1,2,3,4,5])],dtype={ 
        "names":['ss', 'ii'],
        "formats":['U3', '5i4'],
    })
    # 使用自定义字段名来访问
    # print(c[0]['ss']) # 访问到abc
    # print(c[0]['ii']) # 访问到数字
    # print(c[0]['ss'][1]) # 访问b
    # print(c[0]['ii'][2]) # 访问3
    
    # 第四种方式：类型后面跟内存偏移量，也是既可以自定义字段名，又可以使用类型简称
    d = np.array([('abc',[1,2,3,4,5])],dtype={ 
        "ss":('U3', 0),
        "ii":('5i4', 12)
    })
    # 使用自定义字段名来访问
    # print(d[0]['ss']) # 访问到abc
    # print(d[0]['ii']) # 访问到数字
    # print(d[0]['ss'][1]) # 访问b
    # print(d[0]['ii'][2]) # 访问3
    
    # 字节偏移量
    # 同时拥有两个类型：一个u2，一个u1，u1的one偏移量为0，two偏移量为1
    # >表示是大端字节序，前低后高，偏移量为0则是的低的，即12；偏移量为1则是高的，即34
    e = np.array([0x1234], dtype=(
        '>u2',{ 'one':('u1',0), 'two':('u1',1)}
    ))
    print('{:x}'.format(e[0]))  # {:x}表示以16进制访问，e[0]表示第一个类型u2
    print('{:x}、{:x}'.format(e['one'][0],e['two'][0]))
    # 改为小端字节序，前高后低，偏移量为0则是的低的，即34；偏移量为1则是高的，即12
    e = np.array([0x1234], dtype=(
        '<u2',{ 'one':('u1',0), 'two':('u1',1)}
    ))
    print('{:x}、{:x}'.format(e['one'][0],e['two'][0]))

[11]: https://img-blog.csdnimg.cn/20200706114648268.png