[Python] 常用模块（5）：pandas 8

Python 常用模块系列：

• [Python] 常用模块（1）：内建模块 – random & datetime
• [Python] 常用模块（2）：内建模块 – re 以及正则表达式
• [Python] 常用模块（3）：内建模块 – math & itertools
• [Python] 常用模块（4）：NumPy 上
• [Python] 常用模块（4）：NumPy 中
• [Python] 常用模块（4）：NumPy 下
• [Python] 常用模块（5）：pandas 1
• [Python] 常用模块（5）：pandas 2
• [Python] 常用模块（5）：pandas 3
• [Python] 常用模块（5）：pandas 4
• [Python] 常用模块（5）：pandas 5
• [Python] 常用模块（5）：pandas 6
• [Python] 常用模块（5）：pandas 7
• [Python] 常用模块（5）：pandas 8（本文）
• [Python] 常用模块（5）：pandas 9

---

开始以前我们还是要先创建一个数据框。

数据框的变形

将数据框从长变宽：df.pivot(index=None, columns=None, values=none)

>>> df = pd.DataFrame({"b":np.random.randn(8),
...                     "a":[1, 1, 3, 3, 5, 5, 7, 7],
...                     "c":["A", "B", "A", "B"] * 2,
...                     "d":range(8)})
>>> print(df)
          b  a  c  d
0  1.624345  1  A  0
1 -0.611756  1  B  1
2 -0.528172  3  A  2
3 -1.072969  3  B  3
4  0.865408  5  A  4
5 -2.301539  5  B  5
6  1.744812  7  A  6
7 -0.761207  7  B  7

“pivot” 的中文意思是“以…为轴旋转”，所以这个函数是把 index 和 columns 作为轴的两端，把 values 放在中心。我们来感受一下：

>>> print(df.pivot(index="a", columns="c", values="b"))
c         A         B
a                    
1  1.624345 -0.611756
3 -0.528172 -1.072969
5  0.865408 -2.301539
7  1.744812 -0.761207

因为我们只把列 b 作为值，列 d 就被丢弃了。我们当然可以被这列加上：

>>> print(df.pivot(index="a", columns="c", values=["b", "d"]))
          b              d     
c         A         B    A    B
a                              
1  1.624345 -0.611756  0.0  1.0
3 -0.528172 -1.072969  2.0  3.0
5  0.865408 -2.301539  4.0  5.0
7  1.744812 -0.761207  6.0  7.0

将数据框从宽变长：df.melt(id_vars=None, value_vars=None, var_name=None, value_name=None)

melt 可以看成 pivot 的相反操作。除了第一个参数 id_vars 是必须的，其它参数都是可选的，系统会自动处理，只是这样会让数据框变得非常长。var_name value_name 是新的自变量和变量的标签。

>>> print(df.melt(id_vars="c", var_name = "vars", value_name="values"))
    c variable     value
0   A        b  1.624345
1   B        b -0.611756
2   A        b -0.528172
3   B        b -1.072969
4   A        b  0.865408
5   B        b -2.301539
6   A        b  1.744812
7   B        b -0.761207
8   A        a  1.000000
9   B        a  1.000000
10  A        a  3.000000
11  B        a  3.000000
12  A        a  5.000000
13  B        a  5.000000
14  A        a  7.000000
15  B        a  7.000000
16  A        d  0.000000
17  B        d  1.000000
18  A        d  2.000000
19  B        d  3.000000
20  A        d  4.000000
21  B        d  5.000000
22  A        d  6.000000
23  B        d  7.000000
>>> print(df.melt(id_vars="c", value_vars="b", var_name = "vars", value_name="values"))
   c vars    values
0  A    b  1.624345
1  B    b -0.611756
2  A    b -0.528172
3  B    b -1.072969
4  A    b  0.865408
5  B    b -2.301539
6  A    b  1.744812
7  B    b -0.761207

pandas 等级

很多时候数据框内的变量是有限的、重复的变量，比如国家、等级等，这时候把这些变量转换为等级可以提高运算效率，并且易于进行某些统计和运算。

等级的创建

通过指定序列的 dtype 的类型为 category 即可。

>>> cat = pd.Series(["a", "b", "c", "a"])
>>> print(cat)
0    a
1    b
2    c
3    a
dtype: category
Categories (3, object): [a, b, c]

可以看到元素有四个，却只有三个等级。我们也可以创建一个等级对象：

pd.Categorical(values, categories, ordered)

举一个例子：

>>> CAT = pd.Categorical(values=["a", "b", "c", "a"], 
...                     categories=["a", "b", "c"], 
...                     ordered=True)
>>> print(CAT)
[a, b, c, a]
Categories (3, object): [a < b < c]

假如有不存在于等级的值，将被视为 NaN。

>>> c2 = pd.Categorical(values=["a", "b", "c", "a"], 
...                     categories=["a", "b"], 
...                     ordered=True)
>>> print(c2)
[a, b, NaN, a]
Categories (2, object): [a < b]

假如我们把等级储存在一个序列里，操纵等级的办法储存在 Series.cat 里。假如我们把等级储存在一个对象里，等级的所有方法和属性可以通过 dir(Categorial.categories) 到达。查看对象的等级可以直接查看这个属性：

>>> print(c2.categories)
Index(['a', 'b'], dtype='object')

序列中等级的添加：Series.cat.add_categories(levels)

>>> print(cat.cat.add_categories("d"))
0    a
1    b
2    c
3    a
dtype: category
Categories (4, object): [a, b, c, d]

序列中等级的查看、重新赋值：Series.cat.categories

如果没有赋值，则访问此属性可以查看等级；若使用赋值语句，则对等级赋值。

>>> print(cat.cat.categories) # 查看原等级
Index(['a', 'b', 'c'], dtype='object')
>>> cat.cat.categories = ["d", "e", "f"] # 赋值新等级
>>> print(cat.cat.categories)
Index(['d', 'e', 'f'], dtype='object')

序列中重命名等级：Series.cat.rename_categories(levels)

修改以后，序列中对应等级的值也将被改变。

>>> print(cat.cat.rename_categories(["d", "e", "g"]))
0    d
1    e
2    g
3    d
dtype: category
Categories (3, object): [d, e, g]

移除序列中的等级：cat.cat.remove_categories(levels)

移除等级后，序列中存在的值将被设成 NaN。

>>> print(cat.cat.remove_categories(["a", "b"]))
0    NaN
1    NaN
2      c
3    NaN
dtype: category
Categories (1, object): [c]

重新设定等级的排序：cat.cat.reorder_categories(levels)

>>> print(cat.cat.reorder_categories(["c", "b", "a"]))
0    a
1    b
2    c
3    a
dtype: category
Categories (3, object): [c, b, a]