玩转Numpy | 数组在数据分析中5大常用操作（附代码）

数据分析的基本处理流程一般分为 5 个步骤，分别是明确分析任务、数据收集、数据处理、数据分析、数据展示。在前两步中，我们可以使用 Python 中的Numpy 数组进行数据收集和处理（也可以使用其他的包，比 Pandas）。具体在数据分析中，Numpy 数组常用的有以下基本操作。

 0.  Numpy 简介及使用方法

NumPy 是一个 Python 包，代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库，主要用来进行科学计算，支持高级大量的维度数组与矩阵运算，也针对数组运算提供大量的数学函数库，有矢量运算能力，快速、节省空间。使用方法是直接导入即可，如下图：

#倒入numpy 包
import numpy as np

1. 读取文件

数据分析的第一步是读取文件到内存。Numpy 中用到的函数是 loadtxt，具体如下：

#读取文本文件 
np.loadtxt(data_file,delimiter=',',dtype='str',skiprows=1)

语法:
numpy.loadtxt(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)
    #fname 读取的文件名字
    #skiprows是指跳过前1行, 如果设置skiprows=2, 就会跳过前两行
    #输出为浮点数的原因为Python默认的数字的数据类型为双精度浮点数这里的
    #comment的是指, 如果行的开头为# 就会跳过该行

例子：比如读取一个超市的季度销售报表。第一行一般为列名，比如商品名，销售情况等信息。但是在数据处理的时候不需要，直接使用 skiprows 跳过即可。具体代码如下：

data_arr = np.loadtxt(market_q,delimiter=',',dtype='str',skiprows=1)

   2.   数组的属性

在数据分析中，数组的属性可以用来判断倒入内存的数据是不是和原来的文件一样，进而可以判断数据是不是被完全倒入。一般使用 spyder 编译器的 debug 模式进行查找。

主要用到的属性有以下几种： 例子是一个3维数组

"""
    使用数组的属性判断载入的数据是不是正确的。
"""
#数组的属性
print("arrary ",arrary_3)
print("arrary_3 ndim:",arrary_3.ndim)#数组的纬度
print("arrary_3 shape:",arrary_3.shape)#数组的形状，每一个纬度的总大小
print("arrary_3 size:",arrary_3.size)#数组的总大小
print("arrary_3.dtype",arrary_3.dtype) #数组的数据类型
print("arrary_3.nbytes",arrary_3.nbytes,"bytes") #数组总字节书
print("arrary_3.itemsize",arrary_3.itemsize,"bytes") #每个数组元素大小的itemsize

arrary_3  [[[0 1 0 1 9]
  [0 9 2 1 1]
  [0 0 5 9 0]
  [4 6 6 0 2]]

 [[3 3 2 6 0]
  [5 1 3 6 5]
  [5 1 8 0 5]
  [9 8 5 7 8]]

 [[5 8 9 9 1]
  [5 9 1 4 7]
  [7 7 9 7 6]
  [0 3 9 4 4]]]
arrary_3 ndim: 3
arrary_3 shape: (3, 4, 5)
arrary_3 size: 60
arrary_3.dtype int64
arrary_3.nbytes 480 bytes
arrary_3.itemsize 8 bytes

3.  数组的索引

在数据分析中，数组的索引主要是用在数据的处理，根据索引可以找到想要的某一个元素或者某一列元素，比如查找 “超市销售列表” 的最后一列，进而判断是否是会员的列。具体如下：

"""
    数组索引，获取单个元素    
    对应多个列，可以使用负数来获取最后一列
    比如，超市销售列表里面的最后一列：是否是会员的列
"""
#数组的索引
print(arrary_1)
print(arrary_1[0])#the first 
print(arrary_1[5])

#使用负数获取最后一列的值
print(arrary_1[-1])
#使用负数获取倒数一列的值
print(arrary_1[-2])

#对于二维数组的操作
print(arrary_2)
print(arrary_2[0,0])
print(arrary_2[2,-1])
print(arrary_2[2,0])

#修改数组的值
arrary_2[0,0]=12
print(arrary_2[0,0])

#数组的类型是一样的，不能修改，及时是不同个类型也会被修改一样的
#把浮点数复制为整型数组 ，后面的小数部分别舍去
arrary_1[0]= 3.14159
print(arrary_1[0])

print(arrary_3)
#输出结果以此为：
[6 8 4 9 2 1]
6
1
1
2
[[100   3   0   4]
 [  2   0   3   3]
 [  1   2   5   9]]
100
9
1
12
3
[[[0 1 0 1 9]
  [0 9 2 1 1]
  [0 0 5 9 0]
  [4 6 6 0 2]]

 [[3 3 2 6 0]
  [5 1 3 6 5]
  [5 1 8 0 5]
  [9 8 5 7 8]]

 [[5 8 9 9 1]
  [5 9 1 4 7]
  [7 7 9 7 6]
  [0 3 9 4 4]]]

     

 4.  数组切片

在数据处理过程中，数组切片是经常用到的一个操作。它经常和数组索引结合起来使用，进而获取更确切的某些行或者列。具体如下图代码所示：

"""
    数组切片：获取数组子数组
    语法x[start:stop:step]
        默认值：start （开始的位置）=0 ,stop（结束的位置）=纬度的大小，step（步长）=1
    使用场景：
        获取二维数组中的所有行的最后列[:,-1]，所有行的第一列[:0]
"""
#创建一个一维数组，共10个元素
arrary_4=np.arange(10)
print(arrary_4)

#获取整个数组
print(arrary_4[:])

#获取前五个元素
print(arrary_4[:5])

#从第6个元素开始到最后
print(arrary_4[5:])

#每隔一个元素，获取偶数
print(arrary_4[::2])

#每隔一个元素，获取奇数
print(arrary_4[1::2])

#步长为负数时，逆序数组
print(arrary_4[::-1])

#从索引为5的位置（正序的位置开始数），逆序数组，步长为2
print(arrary_4[5::-2])

#二维数组的切片，也是用冒号分割
print(arrary_2)

#获取两行三列
print(arrary_2[:2,:3])
#所有行，每隔一列
print(arrary_2[:,::2])

#所有数组的逆序
print(arrary_2[::-1,::-1])
# 输出结果以此为：
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4]
[5 6 7 8 9]
[0 2 4 6 8]
[1 3 5 7 9]
[9 8 7 6 5 4 3 2 1 0]
[5 3 1]
[[12  3  0  4]
 [ 2  0  3  3]
 [ 1  2  5  9]]
[[12  3  0]
 [ 2  0  3]]
[[12  0]
 [ 2  3]
 [ 1  5]]
[[ 9  5  2  1]
 [ 3  3  0  2]
 [ 4  0  3 12]]

       

5.  数组变形

在数据处理中，数组变形主要是为了方便处理由数组切片得到的数据。一般数组切片得到的数据是行向量，如果想变为列向量，需要使用数组变形。具体的函数是 reshape(x,y)，其中 x 表示行数 ，y 表示列数。

但是记住一点，reshape 形状变化是基于数组元素不能改变的，新形状中所包含的元素个数必须跟原来元素个数一致，如果数组元素发生变化，就会报错。

"""
    数组的变形：reshape（行数,列数）
    改变数组的形状，比如一纬数组变成二维数组，但是新的数组和原来的数组中的个数是一样的。
    如果数组个数改变了， 则会报错。
    如果变形后的数组被改变了，原来的数组也会被改变
"""
#第一种使用场景：把数据，放入一个数组里面。
#把10个数放入一个2x7的数组里面
arrary_5 = np.arange(1,15).reshape(2,7)
print(arrary_5)

#第二种使用场景：把一个一维数组转变成二维的行或者列的矩阵
arrary_6 = np.array([5,7,9])
print(arrary_6)
#把一维的数组，变成一个二维数组，行向量
print(arrary_6.reshape((1,3)))
print(arrary_6.reshape((1,3)).shape)
#把一维的数组，变成一个二维数组，列向量
print(arrary_6.reshape((3,1)))
print(arrary_6.reshape((3,1)).shape)

#如果数据量很大，不知道具体有多少行，可以使用两个方法
#第一个，-1，自动计算行数。1表示确定的列数。一列
print(arrary_6.reshape((-1,1)))
#第二个方法。newaxis关键字获得行向量,也就是增加纬度。相当于none的用法
print(arrary_6[np.newaxis,:])
print(arrary_6[np.newaxis,:].shape)
#第二个方法。newaxis关键字获得列向量
print(arrary_6[:,np.newaxis])
[[ 1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14]]
[5 7 9]
[[5 7 9]]
(1, 3)
[[5]
 [7]
 [9]]
(3, 1)
[[5]
 [7]
 [9]]
[[5 7 9]]
(1, 3)
[[5]
 [7]
 [9]]

这 5 个基本的数组操作是数据处理中经常使用到的，是不是很容易学。如果有问题，可以关注公众号(人工智能与大数据生活（data_circle）)，并且留言与作者交流。