Data Analysis - Day3 - NumPy

定义

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库.

NumPy Ndarray 对象

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

用于存放同类型元素的多维数组。
每个元素在内存中都有相同存储大小的区域。

1. 一个指向数据（内存或内存映射文件中的一块数据）的指针。

2. 数据类型或 dtype，描述在数组中的固定大小值的格子。

3. 一个表示数组形状（shape）的元组，表示各维度大小的元组。

4. 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。
   

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

import numpy as np
import random
t1= np.array([1,2,3])
print(t1)
print(type(t1))
print('*'*50)

t2 = np.array(range(10))
print(t2)
print(type(t2))
print('*'*50)

t3= np.arange(4,10,2)
print(t3)
print(type(t3))
print(t3.dtype)
print('*'*50)

#指定创建数组类型
t4 = np.array(range(1,4),dtype = float)
print(t4)
print(t4.dtype)
print('*'*50)

t5 = np.array(range(1,4),dtype = 'i1')
print(t5)
print(t5.dtype)
print('*'*50)

t6 = np.array([1,1,0,1,0,0],dtype = bool)
print(t6)
print(t6.dtype)
print('*'*50)

#调整数据类型

t7 = t6.astype('int8')
print(t7)
print(t7.dtype)
print('*'*50)

#numpy中的小数

t8 = np.array([random.random() for i in range(10)])
print(t8)
print(t8.dtype)
print('*'*50)

#取小数
t9 = np.round(t8,2)
print(t9)

[1 2 3]
<class 'numpy.ndarray'>
**************************************************
[0 1 2 3 4 5 6 7 8 9]
<class 'numpy.ndarray'>
**************************************************
[4 6 8]
<class 'numpy.ndarray'>
int32
**************************************************
[1. 2. 3.]
float64
**************************************************
[1 2 3]
int8
**************************************************
[ True  True False  True False False]
bool
**************************************************
[1 1 0 1 0 0]
int8
**************************************************
[0.0787024  0.66895246 0.77686629 0.44584123 0.79824835 0.62721225
 0.9284828  0.8998793  0.40946727 0.40369448]
float64
**************************************************
[0.08 0.67 0.78 0.45 0.8  0.63 0.93 0.9  0.41 0.4 ]

数组的形状

ndarray.shep 数组的维度，对于矩阵，n 行 m 列

import numpy as np

t1=np.arange(12)
print(t1)
print(t1.shape)  #一维
print('*'*50)

t2 = np.array([[1,2,3],[4,5,6]])
print(t2)
print(t2.shape)  #二维
print('*'*50)

t3 = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
print(t3)
print(t3.shape)  #三维
print('*'*50)

t4=np.arange(12)
print(t4)
print(t4.reshape(3,4))  #一维改为二维
print('*'*50)

t5=np.arange(24)
print(t5)
print(t5.reshape(2,3,4)) #一维改三维
print('*'*50)
print(t5.reshape(4,6)) #一维改二维
print('*'*50)
print(t5.reshape(24,)) #一维改一维
print('*'*50)
print(t5.reshape(24,1)) #一维改二维
print('*'*50)
print(t5.reshape(1,24)) #一维改二维
print('*'*50)

#不知道数组数量和形状时,把数组转化为一维数组

t5=np.arange(24)
t6=t5.reshape(4,6)
t7 = t6.reshape((t6.shape[0]*t6.shape[1],))

print(t6)
print(t7)
print('*'*50)
#flatten展开  比上一个方法更简单
print(t6.flatten())

[ 0  1  2  3  4  5  6  7  8  9 10 11]
(12,)
**************************************************
[[1 2 3]
 [4 5 6]]
(2, 3)
**************************************************
[[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]]
(2, 2, 3)
**************************************************
[ 0  1  2  3  4  5  6  7  8  9 10 11]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
**************************************************
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
**************************************************
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
**************************************************
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
**************************************************
[[ 0]
 [ 1]
 [ 2]
 [ 3]
 [ 4]
 [ 5]
 [ 6]
 [ 7]
 [ 8]
 [ 9]
 [10]
 [11]
 [12]
 [13]
 [14]
 [15]
 [16]
 [17]
 [18]
 [19]
 [20]
 [21]
 [22]
 [23]]
**************************************************
[[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]]
**************************************************
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
**************************************************
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]

数组的计算

import numpy as np

# 加法

t5=np.arange(24)
t6=t5.reshape(4,6)

print(t6)
t7 = np.arange(100,124).reshape((4,6))
print(t6)
print('*'*50)
print(t7)
print('*'*50)
print(t6+t7)
print('*'*50)

#减法1

t5=np.arange(24)
t6=t5.reshape(4,6)
t8=np.arange(0,6)
print(t5)
print('*'*50)
print(t6)
print('*'*50)
print(t6-t8)
print('*'*50)

#减法2

t5=np.arange(24)
t6=t5.reshape(4,6)
t9=np.arange(4).reshape((4,1))
print(t5)
print('*'*50)
print(t6)
print('*'*50)
print(t6-t9)
print('*'*50)

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
**************************************************
[[100 101 102 103 104 105]
 [106 107 108 109 110 111]
 [112 113 114 115 116 117]
 [118 119 120 121 122 123]]
**************************************************
[[100 102 104 106 108 110]
 [112 114 116 118 120 122]
 [124 126 128 130 132 134]
 [136 138 140 142 144 146]]
**************************************************
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
**************************************************
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
**************************************************
[[ 0  0  0  0  0  0]
 [ 6  6  6  6  6  6]
 [12 12 12 12 12 12]
 [18 18 18 18 18 18]]
**************************************************
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
**************************************************
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
**************************************************
[[ 0  1  2  3  4  5]
 [ 5  6  7  8  9 10]
 [10 11 12 13 14 15]
 [15 16 17 18 19 20]]
**************************************************

numpy转置

numpy.transpose 函数用于对换数组的维度

numpy.transpose(arr, axes)

import numpy as np

t2 = np.arange(24).reshape(4,6)
print(t2)
print('*'*60)
print(t2.transpose())
print('*'*60)
print(t2.T)
print('*'*60)
print(t2.swapaxes(1,0))

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
************************************************************
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]
************************************************************
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]
************************************************************
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]

numpy读取数据

np.loadtxt(frame,dtype=np.float,delimiter=None,skiprows=0,usecols=None,unpack=False)

参数	解释
frame	文件,字符串或者产生器,可以是.gz或bz2压缩文件
dtype	数据类型,可选,CSV的字符串以什么数据类型读入数组中,默认np.float
delimiter	分割字符串,默认是任何空格,改为逗号
skiprows	跳过前X行,一般跳过第一行表头
usecols	读取指定的列,索引,元组类型
unpack	如果True, 读入属性将分别写入不同数组变量,False读入数据只写入一个数组变量(即行变成列,列变成行)

Instance: 美国和英国各自Youtube1000多个视频的点击, ‘views’,‘likes’,‘dislikes’,‘comment_total’ 统计数据.

import numpy as np

us_file_path = 'us_videos_data_numbers.csv'
uk_file_path = 'gb_videos_data_numbers.csv'
t1 = np.loadtxt(us_file_path,delimiter=',',dtype='int')
t2 = np.loadtxt(uk_file_path,delimiter=',',dtype='int')
print(t1)
print('*'*50)

print(t2)

[[4394029  320053    5931]
 [7860119  185853   26679]
 [5845909  576597   39774]
 ...
 [ 104166     152      39]
 [ 650931   19203     309]
 [1546536   36722    1111]]
**************************************************
[[1231231   78240   13548     705]
 [ 494203    2651    1309       0]
 [ 142819   13119     151    1141]
 ...
 [ 379570    7277      88     336]
 [  17141     922       8      59]
 [  79278    2137      19     173]]

numpy索引和切片

取行

print(t2)
print('*'*50)
#取行
print(t2[2])
print('*'*50)

[[1231231   78240   13548     705]
 [ 494203    2651    1309       0]
 [ 142819   13119     151    1141]
 ...
 [ 379570    7277      88     336]
 [  17141     922       8      59]
 [  79278    2137      19     173]]
**************************************************
[142819  13119    151   1141]
**************************************************

取连续的多行

#取连续的多行
print(t2[2:]) #下标是2,也就是第3行
print('*'*50)

[[1231231   78240   13548     705]
 [ 494203    2651    1309       0]
 [ 142819   13119     151    1141]
 ...
 [ 379570    7277      88     336]
 [  17141     922       8      59]
 [  79278    2137      19     173]]
**************************************************
[[ 142819   13119     151    1141]
 [1580028   65729    1529    3598]
 [  40592    5019      57     490]
 ...
 [ 379570    7277      88     336]
 [  17141     922       8      59]
 [  79278    2137      19     173]]
**************************************************

取不连续的多行

#取不连续的多行
print(t2[[2,8,10]])
print('*'*50)
# #

[[1231231   78240   13548     705]
 [ 494203    2651    1309       0]
 [ 142819   13119     151    1141]
 ...
 [ 379570    7277      88     336]
 [  17141     922       8      59]
 [  79278    2137      19     173]]
**************************************************
[[ 142819   13119     151    1141]
 [  65453    2761      33     223]
 [1121715   65988     591   51025]]
**************************************************

取行的另外一种方法

#取行
print(t2[1,:]) #通用做法,逗号前面放行,逗号后面放列
print('*'*50)
print(t2[2:,:])
print('*'*50)
print(t2[[2,8,10],:])
print('*'*50)

取列

#取列
print(t2[:,0])
print('*'*50)

[[1231231   78240   13548     705]
 [ 494203    2651    1309       0]
 [ 142819   13119     151    1141]
 ...
 [ 379570    7277      88     336]
 [  17141     922       8      59]
 [  79278    2137      19     173]]
**************************************************
[ 1231231   494203   142819  1580028    40592   317696   479291 10532409
    65453   751743  1121715   199102  1024398   483360   601419   185541
   814262   169898  1691734   917746    40884   125196   162818  1936216
    22668  1701667    35536   189389   369541  4659935   153427   109101
  4615562   379393   274358   218536  2524251   463425     3263   182142

取连续的多列

#取连续的多列
print(t2[:,2:])
print('*'*50)

[[1231231   78240   13548     705]
 [ 494203    2651    1309       0]
 [ 142819   13119     151    1141]
 ...
 [ 379570    7277      88     336]
 [  17141     922       8      59]
 [  79278    2137      19     173]]
**************************************************
[[13548   705]
 [ 1309     0]
 [  151  1141]
 ...
 [   88   336]
 [    8    59]

取不连续的多列

#取不连续的多列
print(t2[:,[0,2]])
print('*'*50)

[[1231231   78240   13548     705]
 [ 494203    2651    1309       0]
 [ 142819   13119     151    1141]
 ...
 [ 379570    7277      88     336]
 [  17141     922       8      59]
 [  79278    2137      19     173]]
**************************************************
[[1231231   13548]
 [ 494203    1309]
 [ 142819     151]
 ...
 [ 379570      88]
 [  17141       8]
 [  79278      19]]
**************************************************

取行和列 取第三行,第四列的值

#取行和列 取第三行,第四列的值
print(t2[2,3])
a = t2[2,3]
print(type(a))
print('*'*50)

[[1231231   78240   13548     705]
 [ 494203    2651    1309       0]
 [ 142819   13119     151    1141]
 ...
 [ 379570    7277      88     336]
 [  17141     922       8      59]
 [  79278    2137      19     173]]
**************************************************
1141
<class 'numpy.int32'>
**************************************************

取多行和多列 取第3行到第5行,第2列到第4列的值

#取多行和多列 取第3行到第5行,第2列到第4列的值
print(t2[:5,1:4])
b = t2[2:5,1:4]
print(type(b))
print('*'*50)

[[1231231   78240   13548     705]
 [ 494203    2651    1309       0]
 [ 142819   13119     151    1141]
 ...
 [ 379570    7277      88     336]
 [  17141     922       8      59]
 [  79278    2137      19     173]]
**************************************************
[[78240 13548   705]
 [ 2651  1309     0]
 [13119   151  1141]
 [65729  1529  3598]
 [ 5019    57   490]]
<class 'numpy.ndarray'>
**************************************************

取多个不相邻的点

print(t2)
print('*'*50)
#取多个不相邻的点
c = t2[[0,2,2],[0,1,3]]  #(0,0)代表第一个,(2,1)代表第二个数字,(2,3)代表第三个数
print(c)
print('*'*50)

[[4394029  320053    5931   46245]
 [7860119  185853   26679       0]
 [5845909  576597   39774  170708]
 ...
 [ 104166     152      39      36]
 [ 650931   19203     309    2088]
 [1546536   36722    1111    6460]]
**************************************************
[4394029  576597  170708]

numpy数值的修改

numpy数值的替换

import numpy as np
t2 = np.arange(24).reshape(4,6)
print(t2)
print('*'*50)
print(t2<10)
print('*'*50)
print(t2[t2<10])
print('*'*50)
t2[t2<10]=3  #将t2中小于10的数字换成3
print(t2)
print('*'*50)

[[ 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  True  True  True  True  True]
 [ True  True  True  True False False]
 [False False False False False False]
 [False False False False False False]]
**************************************************
[0 1 2 3 4 5 6 7 8 9]
**************************************************
[[ 3  3  3  3  3  3]
 [ 3  3  3  3 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

numpy数值双重替换(单条件)

小于0的替换成0,大于0的替换成10

t2 = np.arange(24).reshape(4,6)
t3 = np.where(t2<10,0,10) #小于10的替换成0,大于10的替换成10
print(t3)

[[ 0  0  0  0  0  0]
 [ 0  0  0  0 10 10]
 [10 10 10 10 10 10]
 [10 10 10 10 10 10]]

numpy数值双重替换(双条件) clip操作

t2 = np.arange(24).reshape(4,6)
t3 = np.clip(t2,10,18) #小于10的替换成10,大于18的替换成18
print(t3)

[[10 10 10 10 10 10]
 [10 10 10 10 10 11]
 [12 13 14 15 16 17]
 [18 18 18 18 18 18]]

numpy中Nan和inf

nan: 当我们读取本地文件为float时,如果有缺失,就会出现Nan
当做了一个不合适的计算时.(无穷大减去无穷小)

1. 两个nan不相等
2. np.nan!=np.nan 返回True
3. 利用以上特性, 判断数组中nan的个数

t2 = np.arange(24).reshape(4,6)
print(t2)
print('*'*50)
t2[:,0]=0
print(t2)
print('*'*50)
print(np.count_nonzero(t2))  #非0的元素个数
print('*'*50)

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
**************************************************
[[ 0  1  2  3  4  5]
 [ 0  7  8  9 10 11]
 [ 0 13 14 15 16 17]
 [ 0 19 20 21 22 23]]
**************************************************
20

查看Nan的元素有多少个

t2=t2.astype(float)
t2[3,3]=np.nan
print(t2) #包含nan
print('*'*50)
print(np.count_nonzero(t2!=t2)) #统计非0个数

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
**************************************************
[[ 0  1  2  3  4  5]
 [ 0  7  8  9 10 11]
 [ 0 13 14 15 16 17]
 [ 0 19 20 21 22 23]]
**************************************************
20
**************************************************
[[ 0.  1.  2.  3.  4.  5.]
 [ 0.  7.  8.  9. 10. 11.]
 [ 0. 13. 14. 15. 16. 17.]
 [ 0. 19. 20. nan 22. 23.]]
**************************************************
1

4. 通过np.isnan()判断一个数字是否是nan,返回book类型
   通过t[np.isnan(t)] = 0 可以把nan换成0
5. nan和任意值计算都为nan

print('*'*50)
print(np.sum(t2))

**************************************************
nan

计算 行, 列的运算

t3= np.arange(12).reshape(3,4)
print(t3)
print('*'*50)
print(np.sum(t3)) #t3个元素相加

**************************************************
66

#计算X轴(列)的值
print('*'*50)
print(np.sum(t3,axis=0))
#计算Y轴(行)的值
print('*'*50)
print(np.sum(t3,axis=1))

**************************************************
[12 15 18 21]
**************************************************
[ 6 22 38]

nan的注意点

做计算时,一般把缺失值nan替换为均值(中值),或者直接删除有缺失值的一行

numpy的常用统计函数

默认返回多维数组的全部的统计结果,如果指定axis则返回一个当前轴上的结果

print(t2)
print('*'*50)
print(t2.sum(axis=0))
print('*'*50)
print(t2.mean(axis=0))
print('*'*50)
print(t2.max(axis=0))
print('*'*50)
print(t2.min(axis=0))
print('*'*50)
print(t2.ptp(axis=0))
print('*'*50)

[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. nan 22. 23.]]
**************************************************
[36. 40. 44. nan 52. 56.]
**************************************************
[ 9. 10. 11. nan 13. 14.]
**************************************************
[18. 19. 20. nan 22. 23.]
**************************************************
[ 0.  1.  2. nan  4.  5.]
**************************************************
[18. 18. 18. nan 18. 18.]
**************************************************

替换Nan的值

#解决nan问题


def fill_ndarray(t1):

    for i in range(t1.shape[1]): #遍历每一列
        temp_col = t1[:,i]  #当前的一列
        nan_num = np.count_nonzero(temp_col!=temp_col)
        if nan_num!=0: #不为0,说明当前列中有nan
            temp_not_nan_col = temp_col[temp_col==temp_col] #当前一列不为nan的array
            temp_not_nan_col.mean()
            temp_col[np.isnan(temp_col)] = temp_not_nan_col.mean() #选中当前为nan的位置,把值赋值为不为nan的均值
    return t1

if __name__=='__main__':
    t1 = np.arange(12).reshape((3, 4)).astype('float')
    t1[1, 2:] = np.nan
    print(t1)
    print('*'*50)
    t1= fill_ndarray(t1)
    print(t1)
    print('*' * 50)

[[ 0.  1.  2.  3.]
 [ 4.  5. nan nan]
 [ 8.  9. 10. 11.]]
**************************************************
[[ 0.  1.  2.  3.]
 [ 4.  5.  6.  7.]
 [ 8.  9. 10. 11.]]
**************************************************

inf: inf表示正无穷 -inf表示无穷