本篇博文是对于 实验楼 里 pandas 语法的一个实验，叫 Pandas 百题大冲关，再加上一些我自己从前遇到过的一些问题，还有很多自己的一些见解，然后在这里做一个总结。

pandas 基础思维导图

因为前面的东西比较基础，有些东西太散了，而且比较偏门，我就做了一个思维导图来分析了一下，顺便查阅了很多资料，补充了一些我之前没有去注意到的点：

pandas总结与思维导图 - 图1

标记红色部分是我觉得重要的，日常分析中经常用的，而橙色相对次之，稍微比红色用得少些。关于缺失值的处理，这个方法蛮多的，但百题中只有去除和插值。我一般是使用取平均的方式，或者拟合，这里也在上述流程图中补充了我的一些想法，比如说还有三次样条插值，中位数等等，有些还需要是具体情况而定。另外这里有一个机制，叫做 broadcasting，下面就来介绍一下。

broadcasting 机制

我们常常会看到 python 编译器会提示如下类型的错误：

  1. ValueError: operands could not be broadcast together with shapes (8,4,3) (2,1)

broadcasting 机制的功能是为了方便不同 shape 的 array（numpy 库的核心数据结构）进行数学运算。

从官网看到的规则翻译成中文则是：

  1. 让所有输入数组都向其中 shape 最长的数组看齐，shape 中不足的部分都通过在前面加 1 补齐
  2. 输出数组的 shape 是输入数组 shape 的各个轴上的最大值
  3. 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错
  4. 当输入数组的某个轴的长度为 1 时，沿着此轴运算时都用此轴上的第一组值

用代码来理解，即是：

  1. >>> a = np.array([1,2,3])
  2. # b = np.array([2,2,2]) --> a*b    # 维度一致，python类列表做法
  3. b = 2    # numpy中的broadcast形式
  4. print(a*b)
  5. array([2，4，6])

而如果维度不一致，那么就会报上面的那个错：

  1. a = np.array([1,2,3])
  2. b = np.array([1,2,3,1,2,3])
  3. a*b
  5. ValueError: operands could not be broadcast together with shapes (3,) (6,)

另外这里需要说的是，关于矩阵与整数的加减乘除法，其实就是矩阵点乘了这个整数，即矩阵内的每个数都与整数进行了运算，而如果是两个数组矩阵，就相当于是按照矩阵乘法的运算：

  • 一维数组置于矩阵乘法的左部，被视为一个行向量；
  • 一维数组置于矩阵乘法的右部，被视为一个列向量；

也就是左行右列的原则。

关于索引，这个还是蛮重要的，不论是在数据库，还是在数据结构，都是无可替代的东西。在打比赛的时候用得也很多，尤其是时间序列索引和 DataFrame 索引，下面我们就来介绍这两个的索引。

时间序列索引

  1. 建立一个以 2018 年每一天为索引，值为随机数的 Series：
  2. >>> dti = pd.date_range(start="2018-01-01",end="2018-12-31",freq="D")
  3. s = pd.Series(np.random.rand(len(dti)),index=dti)
  4. s
  5. --------------------------------------
  6. “”“ 
  7. 2018-01-01    0.084896
  8. 2018-01-02    0.914417
  9. 2018-01-03    0.285811
  10. 2018-01-04    0.945080
  11.                 ......
  12. 2018-12-31    0.446219
  13. ”“”
  1. 统计 s 中每一个周三对应值的和：
  2. >>> print(s[s.index.weekday == 2])
  3. >>> s[s.index.weekday == 2].sum() # # 周一从 0 开始
  4. --------------------------------------
  5. “”“ 
  6. 2018-01-03    0.892325
  7. 2018-01-10    0.917178
  8. 2018-01-17    0.051205
  9.                 ......
  10. 2018-12-26    0.403411
  11. dtype: float64
  12. 25.810026230589507
  13. ”“”
  1. 统计 s 中每个月值的平均值：
  2. >>> s.resample('M').mean()
  3. --------------------------------------
  4. “”“ 
  5. 2018-01-31    0.454337
  6. 2018-02-28    0.677720
  7. 2018-03-31    0.455357
  8. 2018-04-30    0.487341
  9. 2018-05-31    0.488349
  10. 2018-06-30    0.481850
  11. 2018-07-31    0.537994
  12. 2018-08-31    0.524359
  13. 2018-09-30    0.568155
  14. 2018-10-31    0.521819
  15. 2018-11-30    0.479967
  16. 2018-12-31    0.499142
  17. Freq: M, dtype: float64
  18. ”“”
  1. 将 Series 中的时间进行转换：
  1. s = pd.date_range('today', periods=100, freq='S')
  3. ts = pd.Series(np.random.randint(0, 500, len(s)), index=s)
  5. ts.resample('Min').sum()
  6. --------------------------------------
  7. “”“ 
  8. 2018-12-05 11:06:00      715
  9. 2018-12-05 11:07:00    16033
  10. 2018-12-05 11:08:00     8611
  11. Freq: T, dtype: int64
  12. ”“”

DataFrame 多重索引

关于 DataFrame 的索引，很多都是很重要的，在这里我就列举一部分来分析它的

  1. 多重索引求和：
  1. >>> frame = pd.DataFrame(np.arange(12).reshape(6, 2),
  2.                      index=[list('AAABBB'), list('123123')],
  3.                      columns=['hello', 'shiyanlou'])
  4. frame    # 创建一个在0-12之间六行两列的数组，然后加上AAABBB的索引，也就是A、B两类索引
  6. >>>frame.groupby('first').sum()
first hello shiyanlou
A 6 9
B 24 27
  1. DataFrame 条件查找
  1. >>> data = {'animal': ['cat', 'cat', 'snake', 'dog', 'dog', 'cat', 'snake', 'cat', 'dog', 'dog'],
  2.         'age': [2.5, 3, 0.5, np.nan, 5, 2, 4.5, np.nan, 7, 3],
  3.         'visits': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],
  4.         'priority': ['yes', 'yes', 'no', 'yes', 'no', 'no', 'no', 'yes', 'no', 'no']}
  6. labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
  7. df = pd.DataFrame(data, index=labels)
  9. >>>df[df['age'] > 3]
/ animal age visits priority
e dog 5.0 2 no
g snake 4.5 1 no
i dog 7.0 2 no
  1. DataFrame 多重条件查询
  1. >>> df = pd.DataFrame(data, index=labels)
  3. df[(df['animal'] == 'cat') & (df['age'] < 3)]
/ animal age visits priority
a cat 2.5 1 yes
f cat 2.0 3 no
  1. DataFrame 按关键字查询
  1. >>> df3[df3['animal'].isin(['cat', 'dog'])]
/ animal age visits priority
a cat 2.5 1 yes
b cat 3.0 3 yes
d dog NaN 3 yes
e dog 5.0 2 no
f cat 2.0 3 no
h cat NaN 1 yes
i dog 7.0 2 no
j dog 3.0 1 no
  1. DataFrame 多条件排序
    按照 age 降序，visits 升序排列
  1. >>> df.sort_values(by=['age', 'visits'], ascending=[False, True])
/ animal age visits priority
i dog 7.0 2 no
e dog 5.0 2 no
g snake 4.5 1 no
j dog 3.0 1 no
b cat 3.0 3 yes
a cat 2.5 1 yes
f cat 2.0 3 no
c snake 0.5 2 no
h cat NaN 1 yes
d dog NaN 3 yes
  1. DataFrame 分组求和
  1. >>> df.groupby('animal').sum()
animal age visits
cat 7.5 8
dog 15.0 8
snake 5.0 3
  1. DataFrame 多值替换
    将 priority 列的 yes 值替换为 True，no 值替换为 False
  1. >>> df['priority'].map({'yes': True, 'no': False})
  1. 使用列表拼接多个 DataFrame
  1. temp_df1 = pd.DataFrame(np.random.randn(5, 4))  # 生成由随机数组成的 DataFrame 1
  2. temp_df2 = pd.DataFrame(np.random.randn(5, 4))  # 生成由随机数组成的 DataFrame 2
  3. temp_df3 = pd.DataFrame(np.random.randn(5, 4))  # 生成由随机数组成的 DataFrame 3
  5. print(temp_df1)
  6. print(temp_df2)
  7. print(temp_df3)
  9. pieces = [temp_df1, temp_df2, temp_df3]
  10. pd.concat(pieces)

然后还有找出表中和最小的那一列，每一组中最大的三个数的和等等这些，用得不多，所以总结在下面的这张思维导图里。

索引思维导图

pandas总结与思维导图 - 图2

里面介绍了一些上面没有讲到的，然后还是和上面的思维导图一样，红色是我认为重要的，橙色次之。

数据清理

在 FilghtNumber 中有数值缺失，其中数值为按 10 增长，补充相应的缺省值使得数据完整，并让数据为 int 类型，这可以算作是一种基本的拟合。

  1. df = pd.DataFrame({'From_To': ['LoNDon_paris', 'MAdrid_miLAN', 'londON_StockhOlm',
  2.                                'Budapest_PaRis', 'Brussels_londOn'],
  3.                    'FlightNumber': [10045, np.nan, 10065, np.nan, 10085],
  4.                    'RecentDelays': [[23, 47], [], [24, 43, 87], [13], [67, 32]],
  5.                    'Airline': ['KLM(!)', '<Air France> (12)', '(British Airways. )',
  6.                                '12. Air France', '"Swiss Air"']})
  7. df['FlightNumber'] = df['FlightNumber'].interpolate().astype(int)
  8. df
/ From_To FlightNumber RecentDelays Airline
0 LoNDon_paris 10045 [23, 47] KLM(!)
1 MAdrid_miLAN 10055 [] (12)
2 londON_StockhOlm 10065 [24, 43, 87] (British Airways.)
3 Budapest PaRis 10075 [13]
4 Brussels_londOn 10085 [67, 32] “Swiss Air”

然后我们可以通过：

  1. 数据列拆分，因为其中 Fromto 应该为两独立的两列 From 和 To，将 From_to 依照拆分为独立两列建立为一个新表
  2. 然后再进行字符标准化，因为注意到地点的名字都不规范（如：londON 应该为 London）需要对数据进行标准化处理
  3. 再将最开始的 From_to 列删除，加入整理好的 From 和 to 列（这一步我感觉就是将一个特征拆成两个吧，感觉适用场景很少，不会有那么凑巧的列名和数据都能直接拆）
  4. 最后去除多余字符，如同 airline 列中许多数据有许多其他字符，会对后期的数据分析有较大影响，需要对这类数据进行修正。
  1. “”“数据拆分”“”
  2. temp = df.From_To.str.split('_', expand=True)
  3. temp.columns = ['From', 'To']
  4. # print(temp)
  6. ““”字符标准化“””
  7. temp['From'] = temp['From'].str.capitalize()
  8. temp['To'] = temp['To'].str.capitalize()
  10. “”“删除坏数据加入整理好的数据”“”
  11. df = df.drop('From_To', axis=1)
  12. df = df.join(temp)
  13. # print(df)
  15. “”“去除多余字符”“”
  16. df['Airline'] = df['Airline'].str.extract(
  17.     '([a-zA-Z\s]+)', expand=False).str.strip()
  18. print(df)
/ FlightNumber RecentDelays Airline From To
0 10045 [23, 47] KLM London Paris
1 10055 [] Air France Madrid
2 10065 [24, 43, 87] British Airways London Stockholm
3 10075 [13] Air France Budapest Paris
4 10085 [67, 32] Swiss Air Brussels London

数据预处理

班级一部分同学的数学成绩表：

df=pd.DataFrame({‘name’:[‘Alice’,‘Bob’,‘Candy’,‘Dany’,‘Ella’,‘Frank’,‘Grace’,‘Jenny’],‘grades’:[58,83,79,65,93,45,61,88]})

但我们更加关心的是该同学是否及格，将该数学成绩按照是否 > 60 来进行划分。

  1. df = pd.DataFrame({'name': ['Alice', 'Bob', 'Candy', 'Dany', 'Ella',
  2.                             'Frank', 'Grace', 'Jenny'], 'grades': [58, 83, 79, 65, 93, 45, 61, 88]})
  5. def choice(x):
  6.     if x > 60:
  7.         return 1
  8.     else:
  9.         return 0
  12. df.grades = pd.Series(map(lambda x: choice(x), df.grades))
  13. df
- name grades
0 Alice 0
1 Bob 1
2 Candy 1
… … …

一个列为 A 的 DataFrame 数据 df = pd.DataFrame({‘A’: [1, 2, 2, 3, 4, 5, 5, 5, 6, 7, 7]})
尝试将 A 列中连续重复的数据清除。

  1. df = pd.DataFrame({'A': [1, 2, 2, 3, 4, 5, 5, 5, 6, 7, 7]})
  2. df.loc[df['A'].shift() != df['A']]

有时候，DataFrame 中不同列之间的数据差距太大，需要对其进行归一化处理。 其中，Max-Min 归一化是简单而常见的一种方式，公式如下:

Y = X − X m i n X m a x − X m i n Y=\frac{X-X{min}}{X{max}-X_{min}} Y=Xmax−XminX−Xmin

  1. def normalization(df):
  2.     numerator = df.sub(df.min())
  3.     denominator = (df.max()).sub(df.min())
  4.     Y = numerator.div(denominator)
  5.     return Y
  8. df = pd.DataFrame(np.random.random(size=(5, 3)))
  9. print(df)
  10. normalization(df)
  11. ------------------------------
  12. “”“
  13.           0         1         2
  14. 0  0.470056  0.982399  0.363549
  15. 1  0.087079  0.620251  0.194063
  16. 2  0.956984  0.261238  0.605419
  17. 3  0.001150  0.817922  0.629556
  18. 4  0.326190  0.068997  0.505367
  19. Out:
  20. 0    1    2
  21. 0    0.490572    1.000000    0.389182
  22. 1    0.089900    0.603517    0.000000
  23. 2    1.000000    0.210467    0.944577
  24. 3    0.000000    0.819930    1.000000
  25. 4    0.340059    0.000000    0.714832
  26. ”“”
  2. # 第一张图：Series 折线图
  3. import matplotlib
  4. df = pd.Series(np.random.randn(100), index=pd.date_range('today', periods=100))
  5. df = ts.cumsum()
  6. df.subplot(2,2,1)
  7. df.plot()
  9. --------------------------------
  10. # 第二张图：DataFrame 折线图
  11. df = pd.DataFrame(np.random.randn(100, 4), index=ts.index,
  12.                   columns=['A', 'B', 'C', 'D'])
  13. df = df.cumsum()
  14. df.subplot(2,2,4)
  15. df.plot()
  17. --------------------------------
  18. # 第三张图：DataFrame 散点图
  19. df = pd.DataFrame({"xs": [1, 5, 2, 8, 1], "ys": [4, 2, 1, 9, 6]})
  20. df = df.cumsum()
  21. df.subplot(2,3,5)
  22. df.plot.scatter("xs", "ys", color='red', marker="*")
  24. --------------------------------
  25. # 第四张图：DataFrame 柱形图
  26. df = pd.DataFrame({"revenue": [57, 68, 63, 71, 72, 90, 80, 62, 59, 51, 47, 52],
  27.                    "advertising": [2.1, 1.9, 2.7, 3.0, 3.6, 3.2, 2.7, 2.4, 1.8, 1.6, 1.3, 1.9],
  28.                    "month": range(12)
  29.                    })
  31. ax = df.plot.bar("month", "revenue", color="yellow")
  32. df.subplot(2,3,8)
  33. df.plot("month", "advertising", secondary_y=True, ax=ax)

这篇博文总共用时两天，第一天把 pandas 百题大冲关做了 2~3 遍，然后睡了一觉还是很多不记得，所以今天就开始画思维导图，外加上再一边对照代码一边写博客，印象又加深了许多，其实这些语法也是 pandas 里面基础的语法，如果配合着其他的比如说 sklearn、matplotlib 等包一起的话，那么就更加有趣味性和挑战性，这里我也只是比较全面的过一遍 pandas 先，这篇博文相当于留给自己自备，以防以后忘了然后回过头来看看。
https://blog.csdn.net/submarineas/article/details/84800227