数据分析

numpy

数组中的轴：

其实很好理解，越外面循环的 axis 值越小。

一些值得注意的特性：

import numpy as np

t = np.arange(24, dtype=float).reshape(4, 6)

t[2, 4] = np.nan
t[3, 4] = np.nan

print(t)
print(np.count_nonzero(t))
print(np.nan == np.nan)
print(t!=t)
print(np.count_nonzero(t != t))

# 将 nan 换成 0
# t[np.isnan(t)] = 0
t[t!=t] = 0
print(t)

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

改变多维数组的形状（具体细节谷歌搜索）：

np.swapaxes()  # 可用作二维矩阵的转置
np.rollaxis()

一个常用的数据集网站： https://www.kaggle.com/

一个英国和美国 youtube 一千多个视频的点击、喜欢、不喜欢、评论数量的 csv ：
https://www.kaggle.com/datasets/datasnaek/youtube/data

numpy 读取数据 np.loadtxt()，需要关注的参数：

• dtype
• delimiter, 分隔符
• skiprows, 跳过行
• usecols, 读取指定的列、索引、元组类型
• unpack

Pandas

numpy 能够处理数值型数据，但是很多时候，除了数值之外，还有字符串、时间序列等。

Pandas 可以处理 CSV 和文本文件、Microsoft Excel、SQL 数据库和快速 HDF 5 等格式。

Series

Pandas 两个主要的数据结构： Series 和 DataFrame .

Series 是一种类似于一维数组的对象，由一组数据（各种 NumPy 数据类型）及一组与之对应的索引（数据标签）组成。

import pandas as pd

ser_obj = pd.Series(range(10, 20))
print(ser_obj)
print('-' * 50)

# 获取数据
print(ser_obj.values)

# 获取索引
print(ser_obj.index)
print(ser_obj.dtype)

print('-' * 50)

# 一些简单的计算，和 numpy 类似
print(ser_obj * 2)
print(ser_obj > 15)

'''
0    10
1    11
2    12
3    13
4    14
5    15
6    16
7    17
8    18
9    19
dtype: int64
--------------------------------------------------
[10 11 12 13 14 15 16 17 18 19]
RangeIndex(start=0, stop=10, step=1)
int64
--------------------------------------------------
0    20
1    22
2    24
3    26
4    28
5    30
6    32
7    34
8    36
9    38
dtype: int64
0    False
1    False
2    False
3    False
4    False
5    False
6     True
7     True
8     True
9     True
dtype: bool
'''

字典也可以转换为 series, 且 key 和 value 分别对应。

索引建议用 loc, 效率更高。

DataFrame

类似于 excel.

较为灵活的日期功能：

import pandas as pd
import numpy as np

dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))

print(df)

'''
                   A         B         C         D
2013-01-01  0.056948  0.748347  0.158512  1.969863
2013-01-02  0.546564  0.625012 -0.331042 -0.343768
2013-01-03  1.013044  1.915540  0.895085  0.195473
2013-01-04 -0.848951 -0.155895 -2.426352  0.557494
2013-01-05  0.196745 -1.037885 -0.191365  1.632707
2013-01-06 -0.700018 -1.033878 -0.535214  1.476812
'''

pandas 中使用索引名取某一列：

print(df_obj['A']) # 取出来是 series

DataFrame 也可以方便地增加、删除列：

# just an example
df_obj['G'] = df_obj['D'] + 4
del(df_obj['G'])

常见的 Index 种类：

• Index, 普通索引，例如 a, b, c, d, e
• Int64Index, 整数索引
• MultiIndex, 层级索引
• DatetimeIndex, 时间戳类型

DataFrame 也可以用 loc 来拿：

# just an example
print(df_obj.loc['a']) # 拿的是 行

# 第一个参数索引行，第二个参数索引列
print(df_obj.loc['a':'c', 'd':'b'])

iloc 位置索引：

# DataFrame, iloc 是左闭右开
df_obj.iloc[0:2, 0:2]

对齐运算

对齐是数据清洗的重要过程，可以按索引对齐进行运算，如果没对齐的位置则补 NaN，最后也可以填充 NaN.

Series 的对齐运算：

import pandas as pd

s1 = pd.Series(range(10, 20), index = range(10))
s2 = pd.Series(range(20, 25), index = range(5))
print('s1+s2: ' )
s3 = s1 + s2
print(s3)
print(s3[6])

print('--'*10)
print(s1.add(s2, fill_value=0))

'''
s1+s2: 
0    30.0
1    32.0
2    34.0
3    36.0
4    38.0
5     NaN
6     NaN
7     NaN
8     NaN
9     NaN
dtype: float64
nan
--------------------
0    30.0
1    32.0
2    34.0
3    36.0
4    38.0
5    15.0
6    16.0
7    17.0
8    18.0
9    19.0
dtype: float64
'''

DataFrame 的对齐运算：

import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.ones((2,2)), columns=['A', 'B'])
df2 = pd.DataFrame(np.ones((3,3)), columns=['A', 'B', 'C'])
print(df1 - df2)
print(df1.sub(df2, fill_value=2))

'''
     A    B   C
0  0.0  0.0 NaN
1  0.0  0.0 NaN
2  NaN  NaN NaN
     A    B    C
0  0.0  0.0  1.0
1  0.0  0.0  1.0
2  1.0  1.0  1.0
'''

函数应用

关注 apply 和 applymap 相关资料。

通过 apply 将函数（例如 lambda 函数）应用到列或行上。

通过 applymap 将函数应用到每个数据上。

索引排序

排序默认使用升序排序，ascending=False 为降序排序。

import pandas as pd
import numpy as np
s4 = pd.Series(range(10, 15), index = np.random.randint(5, size=5))
print(s4)
# 索引排序
print(s4.sort_index())

'''
3    10
4    11
2    12
3    13
4    14
dtype: int64
2    12
3    10
3    13
4    11
4    14
dtype: int64
'''

上面代码可以简单地拓展到二维的情形。

按值排序

sort_values() .

处理缺失数据

import pandas as pd
import numpy as np

df_data = pd.DataFrame([np.random.randn(3), [1., 2., np.nan],
                       [np.nan, 4., np.nan], [1., 2., 3.]])
print(df_data.head())

print(df_data.isnull())
print(df_data.dropna())
print(df_data.dropna(axis=1))  # 不常用

# 给零列的空值填为 -100
print(df_data.iloc[:,0].fillna(-100.))

'''
         0         1         2
0  0.43007  0.800597 -0.128422
1  1.00000  2.000000       NaN
2      NaN  4.000000       NaN
3  1.00000  2.000000  3.000000
       0      1      2
0  False  False  False
1  False  False   True
2   True  False   True
3  False  False  False
         0         1         2
0  0.43007  0.800597 -0.128422
3  1.00000  2.000000  3.000000
          1
0  0.800597
1  2.000000
2  4.000000
3  2.000000
0      0.43007
1      1.00000
2   -100.00000
3      1.00000
Name: 0, dtype: float64
'''

层级索引（hierarchical indexing）

import pandas as pd
import numpy as np

index1 = pd.MultiIndex.from_arrays([['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                                    [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]], names=['cloth', 'size'])

ser_obj = pd.Series(np.random.randn(12), index=index1)
print(ser_obj)
print(type(ser_obj))
print(type(ser_obj.index))
print(ser_obj.index)
print(ser_obj.index.levels)

'''
cloth  size
a      0      -0.641816
       1       1.454813
       2      -0.348024
b      0       1.984779
       1      -1.063528
       2       0.136670
c      0       0.707680
       1       1.110020
       2      -0.358702
d      0       1.234463
       1       0.369818
       2      -0.294201
dtype: float64
<class 'pandas.core.series.Series'>
<class 'pandas.core.indexes.multi.MultiIndex'>
MultiIndex([('a', 0),
            ('a', 1),
            ('a', 2),
            ('b', 0),
            ('b', 1),
            ('b', 2),
            ('c', 0),
            ('c', 1),
            ('c', 2),
            ('d', 0),
            ('d', 1),
            ('d', 2)],
           names=['cloth', 'size'])
[['a', 'b', 'c', 'd'], [0, 1, 2]]
'''

层级索引可以交换层级。

unstack 操作：

统计计算和描述

sum, mean, max, min, describe:

describe 可以用于观察数据分布，是否有异常值等。

其他 pandas 的操作

下面将使用 Jupyter Notebook .

在 Debian 12 上安装 ipykernel :

sudo apt update
sudo apt install python3-ipykernel

建议使用虚拟环境管理所有数据分析需要的包。

电商数据分析

一般的数据分析流程：

电商平台数据分析：

淘宝用户行为模式分析