7.1 Pandas

原文：Pandas

译者：飞龙

协议：CC BY-NC-SA 4.0

致谢：这个笔记摘自 Wes McKinney 的著作 《Python 数据分析》（Python for Data Analysis）

• 序列（Series）
• 数据帧（DataFrame）
• 重索引
• 删除条目
• 索引，选择和过滤
• 算术和数据对齐
• 函数应用和映射
• 排序和排名
• 带有重复值的轴索引
• 汇总和计算描述性统计量
• 清洗数据（构建中）
• 输入和输出（构建中）

from pandas import Series, DataFrame
import pandas as pd
import numpy as np

序列（Series）

Series是一维数组对象，包含数据数组和相关的数据标签数组。数据可以是任何 NumPy 数据类型，标签是序列的索引。

创建Series：

ser_1 = Series([1, 1, 2, -3, -5, 8, 13])
ser_1

'''
0     1
1     1
2     2
3    -3
4    -5
5     8
6    13
dtype: int64
'''

获取Series的数组表示：

ser_1.values

# array([ 1,  1,  2, -3, -5,  8, 13])

Series对象是不可变的，并持有轴标签和元数据，如名称和轴名称。

获取Series的索引：

ser_1.index

# Int64Index([0, 1, 2, 3, 4, 5, 6], dtype='int64')

使用自定义索引创建Series：

ser_2 = Series([1, 1, 2, -3, -5], index=['a', 'b', 'c', 'd', 'e'])
ser_2

'''
a    1
b    1
c    2
d   -3
e   -5
dtype: int64
'''

从Series获取值：

ser_2[4] == ser_2['e']

# True

通过传入列表从Series获取一组值：

ser_2[['c', 'a', 'b']]

'''
c    2
a    1
b    1
dtype: int64
'''

获取大于 0 的值：

ser_2[ser_2 > 0]

'''
a    1
b    1
c    2
dtype: int64
'''

标量乘法：

ser_2 * 2

'''
a     2
b     2
c     4
d    -6
e   -10
dtype: int64
'''

应用 NumPy 数学函数：

import numpy as np
np.exp(ser_2)

'''
a    2.718282
b    2.718282
c    7.389056
d    0.049787
e    0.006738
dtype: float64
'''

Series就像一个固定长度的有序字典。

传入字典来创建Series：

dict_1 = {'foo' : 100, 'bar' : 200, 'baz' : 300}
ser_3 = Series(dict_1)
ser_3

'''
bar    200
baz    300
foo    100
dtype: int64
'''

通过传入索引来重排Series（未找到的索引是 NaN）：

index = ['foo', 'bar', 'baz', 'qux']
ser_4 = Series(dict_1, index=index)
ser_4

'''
foo    100
bar    200
baz    300
qux    NaN
dtype: float64
'''

使用 pandas 方法检查 NaN：

pd.isnull(ser_4)

'''
foo    False
bar    False
baz    False
qux     True
dtype: bool
'''

使用Series的方法检查 NaN：

ser_4.isnull()

'''
foo    False
bar    False
baz    False
qux     True
dtype: bool
'''

在算术运算中，Series自动对齐不同的索引数据：

ser_3 + ser_4

'''
bar    400
baz    600
foo    200
qux    NaN
dtype: float64
'''

命名Series：

ser_4.name = 'foobarbazqux'

命名Series索引：

ser_4.index.name = 'label'

ser_4

'''
label
foo    100
bar    200
baz    300
qux    NaN
Name: foobarbazqux, dtype: float64
'''

原地重命名Series的索引：

ser_4.index = ['fo', 'br', 'bz', 'qx']
ser_4

'''
fo    100
br    200
bz    300
qx    NaN
Name: foobarbazqux, dtype: float64
'''

数据帧（DataFrame）

DataFrame是表格数据结构，包含列的有序集合。 每列可以是不同的类型。 DataFrame同时具有行索引和列索引，类似于Series的字典。行和列操作大致是对称实现的。 索引DataFrame时返回的列是底层数据的视图，而不是副本。 要获取副本，请使用Series的复制方法。

创建DataFrame:

data_1 = {'state' : ['VA', 'VA', 'VA', 'MD', 'MD'],
          'year' : [2012, 2013, 2014, 2014, 2015],
          'pop' : [5.0, 5.1, 5.2, 4.0, 4.1]}
df_1 = DataFrame(data_1)
df_1

指定列的序列来创建DataFrame：

df_2 = DataFrame(data_1, columns=['year', 'state', 'pop'])
df_2

与Series类似，数据中不存在的列是 NaN：

df_3 = DataFrame(data_1, columns=['year', 'state', 'pop', 'unempl'])
df_3

通过键检索列，返回Series：

df_3['state']

'''
0    VA
1    VA
2    VA
3    MD
4    MD
Name: state, dtype: object
'''

通过属性检索列，返回Series：

df_3.year

'''
0    2012
1    2013
2    2014
3    2014
4    2015
Name: year, dtype: int64
'''

通过位置检索行：

df_3.ix[0]

'''
year      2012
state       VA
pop          5
unempl     NaN
Name: 0, dtype: object
'''

通过复制来更新列：

df_3['unempl'] = np.arange(5)
df_3

将Series赋给列（请注意，如果指定了列表或数组，则长度必须与DataFrame匹配，与Series不同）：

unempl = Series([6.0, 6.0, 6.1], index=[2, 3, 4])
df_3['unempl'] = unempl
df_3

对不存在的新列赋值来创建新列：

df_3['state_dup'] = df_3['state']
df_3

删除一列：

del df_3['state_dup']
df_3

从字典的嵌套字典创建DataFrame（如果没有指定显示索引，内部字典中的键，被合并并排序来形成结果中的索引）：

pop = {'VA' : {2013 : 5.1, 2014 : 5.2},
       'MD' : {2014 : 4.0, 2015 : 4.1}}
df_4 = DataFrame(pop)
df_4

转置DataFrame:

df_4.T

从Series的词典创建一个DataFrame：

data_2 = {'VA' : df_4['VA'][1:],
          'MD' : df_4['MD'][2:]}
df_5 = DataFrame(data_2)
df_5

设置DataFrame的索引名称：

df_5.index.name = 'year'
df_5

设置DataFrame的列名称：

df_5.columns.name = 'state'
df_5

将DataFrame中包含的数据作为 2D ndarray返回：

df_5.values

'''
array([[ nan,  5.2],
       [ 4.1,  nan]])
'''

如果列是不同的dtypes，则 2D 数组的dtype将兼容所有列：

df_3.values

'''
array([[2012, 'VA', 5.0, nan],
       [2013, 'VA', 5.1, nan],
       [2014, 'VA', 5.2, 6.0],
       [2014, 'MD', 4.0, 6.0],
       [2015, 'MD', 4.1, 6.1]], dtype=object)
'''

重索引

使用符合新索引的数据创建新对象。任何缺失值都设置为 NaN。

df_3

行的重新索引将返回具有指定索引的新DataFrame：

df_3.reindex(list(reversed(range(0, 6))))

缺失值可以设置为 NaN 以外的值：

df_3.reindex(range(6, 0), fill_value=0)

插入有序数据，如时间序列：

ser_5 = Series(['foo', 'bar', 'baz'], index=[0, 2, 4])

ser_5.reindex(range(5), method='ffill')

'''
0    foo
1    foo
2    bar
3    bar
4    baz
dtype: object
'''

ser_5.reindex(range(5), method='bfill')

'''
0    foo
1    bar
2    bar
3    baz
4    baz
dtype: object
'''

重索引列：

df_3.reindex(columns=['state', 'pop', 'unempl', 'year'])

重新索引行和列，同时填充行：

df_3.reindex(index=list(reversed(range(0, 6))),
             fill_value=0,
             columns=['state', 'pop', 'unempl', 'year'])

使用ix的重索引：

df_6 = df_3.ix[range(0, 7), ['state', 'pop', 'unempl', 'year']]
df_6

删除条目

从Series或DataFrame中删除行：

df_7 = df_6.drop([0, 1])
df_7

从DataFrame中删除列：

df_7 = df_7.drop('unempl', axis=1)
df_7

索引，选择和过滤

Series索引类似于 NumPy 数组索引，并且能够使用Series的索引值。

ser_2

'''
a    1
b    1
c    2
d   -3
e   -5
dtype: int64
'''

从Series中选择值：

ser_2[0] == ser_2['a']

# True

从Series中选择切片：

ser_2[1:4]

'''
b    1
c    2
d   -3
dtype: int64
'''

从Series中选择特定值：

ser_2[['b', 'c', 'd']]

'''
b    1
c    2
d   -3
dtype: int64
'''

基于过滤器从Series中选择值：

ser_2[ser_2 > 0]

'''
a    1
b    1
c    2
dtype: int64
'''

从带标签的Series中选择切片（注意包含终点）：

ser_2['a':'b']

'''
a    1
b    1
dtype: int64
'''

对Series切片赋值（注意包含终点）：

ser_2['a':'b'] = 0
ser_2

'''
a    0
b    0
c    2
d   -3
e   -5
dtype: int64
'''

Pandas 支持DataFrame中的索引。

df_6

从DataFrame中选择特定列：

df_6[['pop', 'unempl']]

从DataFrame中选择切片：

df_6[:2]

基于过滤器从DataFrame中选择行：

df_6[df_6['pop'] > 5]

在DataFrame上执行标量比较：

df_6 > 5

在DataFrame上执行标量比较，保留满足过滤器的行：

df_6[df_6 > 5]

从DataFrame中选择一行（注意包含终点）：

df_6.ix[2:3]

从DataFrame的特定列中选择行的切片：

df_6.ix[0:2, 'pop']

'''
0    5.0
1    5.1
2    5.2
Name: pop, dtype: float64
'''

根据特定行上的算术运算选择行：

df_6.ix[df_6.unempl > 5.0]

算术和数据对齐

如果索引对不相同，则将Series对象相加会产生索引对的并集，使不重叠的索引为 NaN：

np.random.seed(0)
ser_6 = Series(np.random.randn(5),
               index=['a', 'b', 'c', 'd', 'e'])
ser_6

'''
a    1.764052
b    0.400157
c    0.978738
d    2.240893
e    1.867558
dtype: float64
'''

np.random.seed(1)
ser_7 = Series(np.random.randn(5),
               index=['a', 'c', 'e', 'f', 'g'])
ser_7

'''
a    1.624345
c   -0.611756
e   -0.528172
f   -1.072969
g    0.865408
dtype: float64
'''

ser_6 + ser_7

'''
a    3.388398
b         NaN
c    0.366982
d         NaN
e    1.339386
f         NaN
g         NaN
dtype: float64
'''

为不重叠的索引设置填充值而不是 NaN：

ser_6.add(ser_7, fill_value=0)

'''
a    3.388398
b    0.400157
c    0.366982
d    2.240893
e    1.339386
f   -1.072969
g    0.865408
dtype: float64
'''

如果索引对不相同，则将DataFrame对象相加，会产生行和列的索引对的并集，使不重叠的索引为 NaN：

np.random.seed(0)
df_8 = DataFrame(np.random.rand(9).reshape((3, 3)),
                 columns=['a', 'b', 'c'])
df_8

np.random.seed(1)
df_9 = DataFrame(np.random.rand(9).reshape((3, 3)),
                 columns=['b', 'c', 'd'])
df_9

df_8 + df_9

为不重叠的索引设置填充值而不是 NaN：

df_10 = df_8.add(df_9, fill_value=0)
df_10

与 NumPy 一样，pandas 支持DataFrame和Series之间的算术运算。

在DataFrame的列上匹配Series的索引，并向下广播行：

ser_8 = df_10.ix[0]
df_11 = df_10 - ser_8
df_11

在DataFrame的列上匹配Series的索引，向下广播行并合并不匹配的索引：

ser_9 = Series(range(3), index=['a', 'd', 'e'])
ser_9

'''
a    0
d    1
e    2
dtype: int64
'''

df_11 - ser_9

使用算术方法，在列上广播并匹配行（axis = 0）：

df_10

ser_10 = Series([100, 200, 300])
ser_10

'''
0    100
1    200
2    300
dtype: int64
'''

df_10.sub(ser_10, axis=0)

函数应用和映射

NumPy ufunc（逐元素数组方法）能够操作 pandas 对象：

df_11 = np.abs(df_11)
df_11

将 1D 数组上的函数应用于每列：

func_1 = lambda x: x.max() - x.min()
df_11.apply(func_1)

'''
a    0.111226
b    0.406224
c    0.530438
d    0.396653
dtype: float64
'''

将 1D 数组上的函数应用于每行：

df_11.apply(func_1, axis=1)

'''
0    0.000000
1    0.526508
2    0.382789
dtype: float64
'''

应用函数并返回DataFrame:

func_2 = lambda x: Series([x.min(), x.max()], index=['min', 'max'])
df_11.apply(func_2)

将逐元素的 Python 函数应用于DataFrame：

func_3 = lambda x: '%.2f' %x
df_11.applymap(func_3)

将逐元素的 Python 函数应用于Series：

df_11['a'].map(func_3)

'''
0    0.00
1    0.00
2    0.11
Name: a, dtype: object
'''

排序和排名

ser_4

'''
fo    100
br    200
bz    300
qx    NaN
Name: foobarbazqux, dtype: float64
'''

按照索引排序Series：

ser_4.sort_index()

'''
br    200
bz    300
fo    100
qx    NaN
Name: foobarbazqux, dtype: float64
'''

按照值排序Series：

ser_4.sort_values()

'''
fo    100
br    200
bz    300
qx    NaN
Name: foobarbazqux, dtype: float64
'''

df_12 = DataFrame(np.arange(12).reshape((3, 4)),
                  index=['three', 'one', 'two'],
                  columns=['c', 'a', 'b', 'd'])
df_12

按照索引排序DaraFrame：

df_12.sort_index()

按列倒序排序DaraFrame：

df_12.sort_index(axis=1, ascending=False)

按列排序DaraFrame的值：

df_12.sort_values(by=['d', 'c'])

排名类似于numpy.argsort，除了通过为每个组分配平均排名来打破关系：

ser_11 = Series([7, -5, 7, 4, 2, 0, 4, 7])
ser_11 = ser_11.sort_values()
ser_11

'''
1   -5
5    0
4    2
3    4
6    4
0    7
2    7
7    7
dtype: int64
'''

ser_11.rank()

'''
1    1.0
5    2.0
4    3.0
3    4.5
6    4.5
0    7.0
2    7.0
7    7.0
dtype: float64
'''

根据数据出现在Series中的位置，来排名Series：

ser_11.rank(method='first')

'''
1    1
5    2
4    3
3    4
6    5
0    6
2    7
7    8
dtype: float64
'''

使用分组的最大排名，降序排列Series：

ser_11.rank(ascending=False, method='max')

'''
1    8
5    7
4    6
3    5
6    5
0    3
2    3
7    3
dtype: float64
'''

DataFrame可以按行或列排名。

df_13 = DataFrame({'foo' : [7, -5, 7, 4, 2, 0, 4, 7],
                   'bar' : [-5, 4, 2, 0, 4, 7, 7, 8],
                   'baz' : [-1, 2, 3, 0, 5, 9, 9, 5]})
df_13

在行上（按列）排名DataFrame：

df_13.rank()

在列上（按行）排名DataFrame：

df_13.rank(axis=1)

带有重复值的轴索引

标签在 Pandas 中不一定是唯一的：

ser_12 = Series(range(5), index=['foo', 'foo', 'bar', 'bar', 'baz'])
ser_12

'''
foo    0
foo    1
bar    2
bar    3
baz    4
dtype: int64
'''

ser_12.index.is_unique

# False

选择序列的元素：

ser_12['foo']

'''
foo    0
foo    1
dtype: int64
'''

选择DataFrame的元素：

df_14 = DataFrame(np.random.randn(5, 4),
                  index=['foo', 'foo', 'bar', 'bar', 'baz'])
df_14

df_14.ix['bar']

汇总和计算描述性统计量

与 NumPy 数组不同，Pandas 描述性统计量会自动排除缺失数据。 除非整行或列为 NA，否则将排除 NaN 值。

df_6

df_6.sum()

'''
pop          23.4
unempl       18.1
year      10068.0
dtype: float64
'''

按行求和：

df_6.sum(axis=1)

'''
0    2017.0
1    2018.1
2    2025.2
3    2024.0
4    2025.2
5       0.0
6       0.0
dtype: float64
'''

计入 NaN:

df_6.sum(axis=1, skipna=False)

'''
0       NaN
1       NaN
2    2025.2
3    2024.0
4    2025.2
5       NaN
6       NaN
dtype: float64
'''

清洗数据（构建中）

• 替换
• 删除
• 连接

from pandas import Series, DataFrame
import pandas as pd

创建DataFrame：

data_1 = {'state' : ['VA', 'VA', 'VA', 'MD', 'MD'],
          'year' : [2012, 2013, 2014, 2014, 2015],
          'population' : [5.0, 5.1, 5.2, 4.0, 4.1]}
df_1 = DataFrame(data_1)
df_1

替换

将字符串的所有出现替换为另一个字符串（不复制）：

df_1.replace('VA', 'VIRGINIA', inplace=True)
df_1

在指定的列中，将字符串的所有出现替换为另一个字符串（不复制）：

df_1.replace({'state' : { 'MD' : 'MARYLAND' }}, inplace=True)
df_1

删除

删除'population'列并返回DataFrame的副本：

df_2 = df_1.drop('population', axis=1)
df_2

连接

连接两个DaraFrame：

data_2 = {'state' : ['NY', 'NY', 'NY', 'FL', 'FL'],
          'year' : [2012, 2013, 2014, 2014, 2015],
          'population' : [6.0, 6.1, 6.2, 3.0, 3.1]}
df_3 = DataFrame(data_2)
df_3

df_4 = pd.concat([df_1, df_3])
df_4

输入和输出（构建中）

• 读
• 写

from pandas import Series, DataFrame
import pandas as pd

读

将 CSV 文件中的数据读入DataFrame（对 TSV 使用sep='\t'）：

df_1 = pd.read_csv("../data/ozone.csv")

获取DataFrame的摘要：

df_1.describe()

列出DataFrame的前五行：

df_1.head()

写

创建 CSV 文件的副本，以 UTF-8 编码并隐藏索引和标题标签：

df_1.to_csv('../data/ozone_copy.csv', 
            encoding='utf-8', 
            index=False, 
            header=False)

查看数据目录：

!ls -l ../data/

'''
total 1016
-rw-r--r--   1 donnemartin  staff  437903 Jul  7  2015 churn.csv
-rwxr-xr-x   1 donnemartin  staff   72050 Jul  7  2015 confusion_matrix.png
-rw-r--r--   1 donnemartin  staff    2902 Jul  7  2015 ozone.csv
-rw-r--r--   1 donnemartin  staff    3324 Apr  1 07:18 ozone_copy.csv
drwxr-xr-x  10 donnemartin  staff     340 Jul  7  2015 titanic
'''