数据分析之numpy

Numpy的使用

一：Numpy数组的创建

1） 使用np来生成一个有序的一维数组

ls1=np.arange(10)

ls1

输出：array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

2）通过数组创建np数组

arr1=np.array([1,10,5,2,30,20])

arr1

输出：array([ 1, 10, 5, 2, 30, 20])

通过元组创建np数组
arr3=np.array(((1,1,1,1,2),(2,2,2,2,2)))

arr3

输出：array([[1, 1, 1, 1, 2], [2, 2, 2, 2, 2]])

4)创建空数组

np.empty(3)
输出：array([0., 0., 0.])
二：二维及多维数组的创建

二维数组的创建

1)元组套元组

arr3=np.array(((1,1,1,1,2),(2,2,2,2,2)))

arr3

输出：array([[1, 1, 1, 1, 2], [2, 2, 2, 2, 2]])

创建全一数组

np.ones(3)
输出：array([1., 1., 1.])
创建全零数组：

np.zeros(3)

输出：array([0., 0., 0.])
创建元素全为一的3*4的二维数组

np.ones([3,4]

输出：
array([[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]])
创建元素全为零的3*4全零数组

np.zeros([3,4])

输出：array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
查看数组的形状：

arr.shape
查看数组的数据类型：

arr.dtype
将多维数组展开：

例：arr5=np.empty([3,4])

arr5

输出：array([[1.03156124e-311, 3.16202013e-322, 0.00000000e+000,
0.00000000e+000],

[0.00000000e+000, 9.68744731e-071, 1.69184165e-052,
8.77838469e-071],
[4.98778453e-037, 6.40440036e+170, 1.33532526e+165,
1.61997615e-051]])

对arr5数组展开，即降维

arr6=arr5.ravel()  #降维
arr6

输出：
array([1.03156124e-311, 3.16202013e-322, 0.00000000e+000, 0.00000000e+000,

0.00000000e+000, 9.68744731e-071, 1.69184165e-052, 8.77838469e-071,
4.98778453e-037, 6.40440036e+170, 1.33532526e+165, 1.61997615e-051])
使用flatten函数可以实现相同的效果

arr7=arr5.flatten()

arr7

输出：

array([1.03156124e-311, 3.16202013e-322, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 9.68744731e-071, 1.69184165e-052, 8.77838469e-071,
4.98778453e-037, 6.40440036e+170, 1.33532526e+165, 1.61997615e-051])
返回数组的维数：

arr.ndim
返回数组中元素的个数

arr.size
返回数组转置的结果

arr.T

数组的级联

arr8=np.zeros([3,4])
arr9=np.ones([3,4])
水平级联

水平级联的行数必须相同

np.hstack((arr8,arr9))

输出：
    
    array([[0., 0., 0., 0., 1., 1., 1., 1.],

[0., 0., 0., 0., 1., 1., 1., 1.],
[0., 0., 0., 0., 1., 1., 1., 1.]])
纵向级联

纵向级联的列数必须相同

np.vstack((arr8,arr9))

输出：
    
    array([[0., 0., 0., 0.],

[0., 0., 0., 0.],
[0., 0., 0., 0.],
[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]])

水平连接：
与水平级联效果相同
np.column_stack((arr8,arr9))
输出：
array([[0., 0., 0., 0., 1., 1., 1., 1.],
[0., 0., 0., 0., 1., 1., 1., 1.],
[0., 0., 0., 0., 1., 1., 1., 1.]])

纵向连接：
    纵向连接与纵向级联的效果相同
    arr11=np.row_stack((arr8,arr9))
    arr11
    输出：
        array([[0., 0., 0., 0.],
               [0., 0., 0., 0.],
               [0., 0., 0., 0.],
               [1., 1., 1., 1.],
               [1., 1., 1., 1.],
               [1., 1., 1., 1.]])

形状重置：

arr12=arr11.reshape(4,6)
arr12

输出：
array([[0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0.],
[1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1.]])

使用reshape对形状的改变并不会影响原数组

如果想要改变原有数组的形状，可以使用resize()函数

arr11.resize(4,6)
arr11
输出：
array([[0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0.],
[1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1.]])
将ndArray数组转为list

data=arr11.tolist()

type(data)

输出：
list
data
输出:
[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
将list转为ndArray:

data1=np.array(data)

type(data1)
输出：
numpy.ndarray
data1
输出:
array([[0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0.],
[1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1.]])
数据类型转换：

arr11.astype(int)
输出：
array([[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1]])
数组元素的获取：

data2=np.array(np.arange(10))
data2
输出：
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
以下标方式获取元素：
data2[3]
输出：
3
获取前三个元素
data2[:3]
输出：
array([0, 1, 2])
获取第四个元素后的所有元素
data2[3:]
输出：
array([3, 4, 5, 6, 7, 8, 9])

获取最后两位：
    data2[-2:]
    输出：
        array([8, 9])

步长为2取数
    data2[::2]
    输出：
        array([0, 2, 4, 6, 8])
建立一个3*4的数组
arr8=np.array(np.arange(12)).reshape(3,4)
arr8
输出：
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
#取前两行前两列的数据
arr8[:2,:2]
输出：
    array([[0, 1],
            [4, 5]])

获取第一行的数据
arr8[0]
输出：
    array([0, 1, 2, 3])
获取前两行前两列的数据
arr8[:2,:2]
输出：
    array([[0, 1],
        [4, 5]])
        
获取第一行与第三行
arr8[[0,2]]
输出：
    array([[ 0,  1,  2,  3],
            [ 8,  9, 10, 11]])


获取所有行的第一列
    arr8[:,0]
    输出：
        array([0, 4, 8])
获取所有行最后两列
    arr8[:,-2:]
    输出：
        array([[ 2,  3],
               [ 6,  7],
               [10, 11]])
               
               
获取所有行的第一列和第三列的数据

    arr8[:,[0,2]]
    输出：
        array([[ 0,  2],
               [ 4,  6],
               [ 8, 10]])
               
获取第二行第三列的数据    
    
    arr8[1,2]
    
    输出：6

布尔索引：

log=np.array([True,False,False,True,True,False])
arr9=np.array(np.arange(24)).reshape(6,4)
arr9
输出：
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]])
获取所有为true的对应的行

arr9[log]

输出：
array([[ 0, 1, 2, 3],
[12, 13, 14, 15],
[16, 17, 18, 19]])
返回所有为False对应的行

arr9[~log]

输出：
array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[20, 21, 22, 23]])

案例：
生成一个包含有七个元素的一维数组
area=np.array(['A','B','A','C','A','B','D'])
area
输出：
array(['A', 'B', 'A', 'C', 'A', 'B', 'D'], dtype='<U1')
生成一个7*3的二维数组

observes=np.array(np.arange(21)).reshape(7,3)
observes
输出：
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11],
[12, 13, 14],
[15, 16, 17],
[18, 19, 20]])
在area中，A出现的索引位置为0,2,4，通过A的索引获取observes对应索引行的数据:

observes[area=='A']
输出：
array([[ 0, 1, 2],
[ 6, 7, 8],
[12, 13, 14]])
通过c在area中的索引位置来获取observes对应行的数据

observes[area=='C']

    输出：
        array([[ 9, 10, 11]])

通过a和d在area中的索引位置来获取observes对应行的数据

observes[(area'A') |(area'D')]
输出：
array([[ 0, 1, 2],
[ 6, 7, 8],
[12, 13, 14],
[18, 19, 20]])

返回A区域的所有行，且只获取第1列与第3列数据

observes[area=='A'][:,[0,2]]
输出：
array([[ 0, 2],
[ 6, 8],
[12, 14]])
花式索引：

实际上就是将数组作为索引将原数组的元素提取出来

arr10=np.arange(1,29).reshape(7,4)
arr10
输出：
    array([[ 1,  2,  3,  4],
           [ 5,  6,  7,  8],
           [ 9, 10, 11, 12],
           [13, 14, 15, 16],
           [17, 18, 19, 20],
           [21, 22, 23, 24],
           [25, 26, 27, 28]])

将第二行，第四行，第六行，第七行数据返回
arr10[1,3,5,6]
输出：
array([[ 5, 6, 7, 8],
[13, 14, 15, 16],
[21, 22, 23, 24],
[25, 26, 27, 28]])
返回第二行第三行对应的第二列与第三列：

arr10[[1,2]][:,[1,2]]
输出：
array([[ 6, 7],
[10, 11]])
如果想使用比较简单的方式返回指定行以列的二维数组的话，可以使用ix_()函数

返回第一行後三行，第四行的第一列第四列与第二列

    arr10[np.ix_([0,2,3],[0,3,2])]
    
    输出：
        array([[ 1,  4,  3],
               [ 9, 12, 11],
               [13, 16, 15]])

统计函数与线性代数运算

统计运算中常见的聚合函数有：最小值、最大值、中位数、均值、方差、标准差等。首先来看看数组元素级别的计算：

 arr11=5-np.arange(1,13).reshape(4,3)
 arr11
 
 输出：
    array([[ 4,  3,  2],
           [ 1,  0, -1],
           [-2, -3, -4],
           [-5, -6, -7]])
           
arr12=np.random.randint(1,10,size=12).reshape(4,3)
arr12
输出：
    array([[9, 7, 2],
           [1, 1, 8],
           [7, 8, 8],
           [2, 8, 9]])
           
arr13=arr11**2
arr13
输出：
    array([[4., 3., 2.],
           [1., 0., 1.],
           [2., 3., 4.],
           [5., 6., 7.]])

#计算arr13中每个元素的平方根
np.sqrt(arr13)
输出：
    array([[4., 3., 2.],
           [1., 0., 1.],
           [2., 3., 4.],
           [5., 6., 7.]])

计算arr13中每个元素的指数值

    np.exp(arr13)
    
    输出：
        array([[8.88611052e+06, 8.10308393e+03, 5.45981500e+01],
               [2.71828183e+00, 1.00000000e+00, 2.71828183e+00],
               [5.45981500e+01, 8.10308393e+03, 8.88611052e+06],
               [7.20048993e+10, 4.31123155e+15, 1.90734657e+21]])

计算arr13中每个元素的自然对数值
np.log(arr13)

输出：
      array([[2.77258872, 2.19722458, 1.38629436],
       [0.        ,       -inf, 0.        ],
       [1.38629436, 2.19722458, 2.77258872],
       [3.21887582, 3.58351894, 3.8918203 ]])

计算每个元素的绝对值

np.abs(arr13)

整除

arr11//2

输出：
    array([[ 2,  1,  1],
           [ 0,  0, -1],
           [-1, -2, -2],
           [-3, -3, -4]], dtype=int32)

取余数

arr11%3
输出：
    array([[1, 0, 2],
           [1, 0, 2],
           [1, 0, 2],
           [1, 0, 2]], dtype=int32)

统计运算函数

计算所有元素之和
np.sum(arr11)
输出：
-18
对每一列求和

np.sum(arr11,axis=0)

输出：
    array([ -2,  -6, -10])

形状相同的数组间元素操作

arr11+arr12
输出：
array([[ 6, 9, 4],
[ 7, 5, 7],
[ 1, 6, 3],
[ 2, 0, -4]])

arr11*arr12

输出：
array([[ 8, 18, 4],
[ 6, 0, -8],
[ -6, -27, -28],
[-35, -36, -21]])

整除

arr11//arr12
输出：
    array([[ 2,  0,  1],
           [ 0,  0, -1],
           [-1, -1, -1],
           [-1, -1, -3]], dtype=int32)

除arr11/arr12

arr11/arr12

输出：    
    array([[ 2.        ,  0.5       ,  1.        ],
   [ 0.16666667,  0.        , -0.125     ],
   [-0.66666667, -0.33333333, -0.57142857],
   [-0.71428571, -1.        , -2.33333333]])

取余

arr11%arr12

输出：
    array([[0, 3, 0],
           [1, 0, 7],
           [1, 6, 3],
           [2, 0, 2]], dtype=int32)

对所有元素求和
np.sum(arr11)

输出：
    -18

对每一列求和

np.sum(arr11,axis=0)
输出：
array([ -2, -6, -10])
对每一行求和

np.sum(arr11,axis=1)
输出：
array([ 9, 0, -9, -18])
求每一列的累积和，并返回二维数组

np.cumsum(arr11,axis=0)
输出：
array([[ 4, 3, 2],
[ 5, 3, 1],
[ 3, 0, -3],
[ -2, -6, -10]], dtype=int32)
计算每一列的累计积

np.cumprod(arr11,axis=1)
输出：
array([[ 4, 12, 24],
[ 1, 0, 0],
[ -2, 6, -24],
[ -5, 30, -210]], dtype=int32)
计算所有元素中的最小值

np.min(arr11)

输出：

-7

计算所有元素中的最大值
np.max(arr11)

输出：
    4

计算每一列的最大值

np.max(arr11,axis=0)

输出：
array([4, 3, 2])
计算每一行的最大值

np.max(arr11,axis=1)
输出：
array([ 4, 1, -2, -5])
计算所有元素的平均值

np.mean(arr11)
计算每一列的均值

np.mean(arr11,axis=0)
计算每一行的均值

np.mean(arr11,axis=1)
计算所有元素的中位数

np.median(arr11)
计算所有元素方差

np.var(arr11)
np.where

np.where(condition, x, y)

满足条件(condition)，输出x，不满足输出y。
arr11
输出：
array([[ 4, 3, 2],
[ 1, 0, -1],
[-2, -3, -4],
[-5, -6, -7]])
np.where(arr11<0,'小于零','大于零')
输出：
array([['大于零', '大于零', '大于零'],
['大于零', '大于零', '小于零'],
['小于零', '小于零', '小于零'],
['小于零', '小于零', '小于零']], dtype='<U3')
np.where(condition)：

只有条件 (condition)，没有x和y，则输出满足条件 (即非0) 元素的坐标 (等价于numpy.nonzero)。这里的坐标以tuple的形式给出， #通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。

a=np.array([2,4,6,8,10])
返回a中大于5的元素索引
np.where(a>5)
输出：
(array([2, 3, 4], dtype=int64),)
返回a中大于5的元素
a[np.where(a>5)]
输出：
array([ 6, 8, 10])
其它函数：

np.unique( )的用法 该函数是去除数组中的重复数字，并进行排序之后输出。
np.unique([1,1,2,3,4])

输出：
array([1, 2, 3, 4])
intersect1d(x,y)：计算x和y的公共元素，即交集

x=np.array([1,2,3,4,5]) y=np.array([4,5,6,7,8]) 取x,y的交集 np.intersect1d(x,y)

输出：array([4, 5])
union1d(x,y):计算x和y的并集

np.union1d(x,y)
输出：
array([1, 2, 3, 4, 5, 6, 7, 8])
setdiff1d(x,y):计算x和y的差集，即元素在x中，不在y中

np.setdiff1d(x,y)
输出：
array([1, 2, 3])
setxor1d(x,y):计算集合的对称差，即存在于一个数组中，但不同时存在于两个数组中

np.setxor1d(x,y)
输出：
array([1, 2, 3, 6, 7, 8])
in1d(x,y):判断x的元素是否包含于y中

np.inld(x,y)
输出：
array([False, False, False, True, True])
找出x在y中的元素

x[np.inld(x,y)]
输出：
array([4, 5])