手把手玩转 | 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]]

           这五个基本的数组操作是数据处理中经常使用到的，是不是很容易学。如果有问题，可以关注公众号，并且留言与作者交流吧。

---

    

更多精彩内容，

请关注人工智能与大数据生活