Pandas教程整理

一、数据结构

 Pandas包含两种数据结构（Panel在0.25.0版本已经移除，所以只剩两种数据结构）

• Series：一维数组
• DataFrame：一般是二维，大小可变

二、Series（系列）

（一）创建

  pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)

• data：数组类，可迭代对象，字典或者标量(array-like, Iterable, dict, or scalar value)。创建系列的数据。
• index：数组类或者一维的索引序列(array-like or Index (1d))。系列的索引。index必须是跟数据长度一样的离散值，可以不唯一，如果未设置则会默认为(0, 1, 2, …, n)。如果字典和索引序列同时使用，索引序列会覆盖字典的键。
• dtype：字符串，numpy.dtype或拓展的类型，可选参数。Series的数据类型。
• copy：布尔值，默认值为False。是否建立副本。

输入：

import pandas as pd

x = pd.Series(data=[1, 2, 3], index=list('abc'), dtype=float, name='Magic')
print(x)
print('the Series\'s name is:', x.name)

输出：

a    1.0
b    2.0
c    3.0
Name: Magic, dtype: float64
the Series's name is: Magic

1. 用Ndarray创建Series

输入：

d = np.array([1, 2, 3, 4])
x = pd.Series(d)
print(x)

输出：

0    1
1    2
2    3
3    4
dtype: int32

2. 用字典创建Series

  用字典创建Series时，如果没有指定索引，则以字典的键作为索引；如果指定了索引，则以指定索引为索引，对应的值就是字典中对应键的值。

输入：

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
x = pd.Series(d)
y = pd.Series(d, index=['d', 'b', 'a', 'e']) # 索引e在字典d中没有这个键，所以为NaN
print(x)
print(y)

输出：

a    1
b    2
c    3
d    4
dtype: int64

d    4.0
b    2.0
a    1.0
e    NaN
dtype: float64

3. 用标量创建Series

  提供了索引的，将重复该值以匹配索引的长度。

输出：

x = pd.Series(2)
y = pd.Series(6, index=list('abc')) # 匹配索引长度
print(x)
print(y)

输出：

0    2
dtype: int64

a    6
b    6
c    6
dtype: int64

（二）选择元素

1. 使用下标

输入：

x = pd.Series(range(1, 6), index=list('abcde'))
print(x)
print('下标2：\n', x[2])
print('切片[:2]：\n', x[:2])
print('切片[-2:]：\n', x[-2:])

输出：

a    1
b    2
c    3
d    4
e    5
dtype: int64
下标2：
 3
切片[:2]：
a    1
b    2
dtype: int64
切片[-2:]：
d    4
e    5
dtype: int64

2. 使用索引

输入：

x = pd.Series(range(1, 6), index=list('abcde'))
print(x)
print('索引b：\n', x['b'])
print('索引a,c,d：\n', x[['a', 'c', 'd']])

输出：

a    1
b    2
c    3
d    4
e    5
dtype: int64
索引b：
 2
索引a,c,d：
a    1
c    3
d    4
dtype: int64

（三）基本属性

1. axes：返回行轴标签列表。
2. dtype：返回数据类型。
3. empty：返回系列是否为空。
4. ndim：返回数据维数。
5. size：返回元素个数。
6. values：将系列作为 ndarray 返回。
7. head()：返回前 n 行。n默认为5。
8. tail()：返回后 n 行。n默认为5。
输入：

s = pd.Series([1, 3, 4, 7], index=list('abcd'))
print('axes:\n', s.axes)
print('dtype:', s.dtype)
print('empty:', s.empty)
print('ndim:', s.ndim)
print('size:', s.size)
print('values:\n', s.values)
print('head:\n', s.head(2))
print('tail:\n', s.tail(2))

输出：

axes:
 [Index(['a', 'b', 'c', 'd'], dtype='object')]
dtype: int64
empty: False
ndim: 1
size: 4
values:
 [1 3 4 7]
head:
a    1
b    3
dtype: int64
tail:
c    4
d    7
dtype: int64

三、DataFrame（数据帧）

（一）创建

  pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)

• data：ndarray, Iterable, dict, or DataFrame。创建数据帧的数据。字典可以包括Series，数组，常数，列表对象。
• index：Index or array-like。数据帧的行索引。index必须是跟数据行数一样，如果未设置则会默认为(0, 1, 2, …, n)。
• columns：Index or array-like。数据帧的列标签。columns必须是跟数据列数一样，如果未设置则会默认为(0, 1, 2, …, n)。
• dtype：dtype，默认值为None。数据类型。
• copy：布尔值，默认值为False。是否建立副本。

1. 用List创建DataFrame

输入：

x = pd.DataFrame([11, 22, 33])
y = pd.DataFrame([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]], index=[11, 22, 33], columns=list('abc'))
print(x)
print(y)

输出：

    0
0  11
1  22
2  33

    a  b  c
11  1  2  3
22  4  5  6
33  7  8  9

2. 用字典创建DataFrame

输入：

a = pd.DataFrame({'a': 1, 'b': 2}, index=['A'])  # 全使用标量时必须传入index
b = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
c = pd.DataFrame([{'a': 1, 'b': 2}, {'a': 11, 'b': 22, 'c': 33}]) # 字典列表
print('a:\n', a)
print('b:\n', b)
print('c:\n', c)

输出：

a:
    a  b
A  1  2

b:
    a  b
0  1  4
1  2  5
2  3  6

c:
     a   b     c
0   1   2   NaN
1  11  22  33.0 # 空位补NaN

3. 用Series创建DataFrame

输入：

d = {'Name': pd.Series(['Jhon', 'Todd'], index=['a', 'b']),
     'Age': pd.Series(['10', '20', '30'], index=['a', 'b', 'c'])}
df = pd.DataFrame(d)
print(df)

输出：

   Name Age
a  Jhon  10
b  Todd  20
c   NaN  30

4. 用Ndarray创建DataFrame

输入：

d = np.array([[1, 2, 3], [4, 5, 6]])
df = pd.DataFrame(d)
print(df)

输出：

   0  1  2
0  1  2  3
1  4  5  6

5. 用DataFrame创建DataFrame

输入：

a = pd.DataFrame([1, 2, 3])
b = pd.DataFrame([11, 22, 33])
df = pd.DataFrame(a + b)
print(df)

输出：

    0
0  12
1  24
2  36

（二）操作

1.选择元素

(1) .loc()

  根据标签选择元素。
输入：

df = pd.DataFrame([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12],
                   [13, 14, 15, 16]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df)
print('使用单个标签，返回Series：\n', df.loc['r3'])
print('使用标签列表，返回DataFrame：\n', df.loc[['r3', 'r2']])
print('使用布尔值列表，返回DataFrame：\n', df.loc[[False, True, False, True]])  # 注意布尔值列表长度和行数必须一样
print('使用单个标签，返回某一行某一列交叉处的数字：\n', df.loc['r4', 'c1'])
print('使用切片，返回DataFrame：\n', df.loc['r1':'r3', 'c3':])  # 注意首尾都包括在内
print('使用条件选择，返回DataFrame：\n', df.loc[df['c1'] > 5])  # 注意条件这里只能用列
print('使用条件选择，返回DataFrame：\n', df.loc[df['c1'] > 5, ['c1', 'c2']])

输出：

   c1  c2  c3  c4
r1   1   2   3   4
r2   5   6   7   8
r3   9  10  11  12
r4  13  14  15  16
使用单个标签，返回Series：
c1     9
c2    10
c3    11
c4    12
Name: r3, dtype: int64
使用标签列表，返回DataFrame：
     c1  c2  c3  c4
r3   9  10  11  12
r2   5   6   7   8
使用布尔值列表，返回DataFrame：
     c1  c2  c3  c4
r2   5   6   7   8
r4  13  14  15  16
使用单个标签，返回某一行某一列交叉处的数字：
 13
使用切片，返回DataFrame：
     c3  c4
r1   3   4
r2   7   8
r3  11  12
使用条件选择，返回DataFrame：
     c1  c2  c3  c4
r3   9  10  11  12
r4  13  14  15  16
使用条件选择，返回DataFrame：
     c1  c2
r3   9  10
r4  13  14

(2) .iloc()

  根据下标选择元素。
输入：

df = pd.DataFrame([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12],
                   [13, 14, 15, 16]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df)
print('使用单个标签，返回Series：\n', df.iloc[1])
print('使用标签列表，返回DataFrame：\n', df.iloc[[0, 2]])
print('使用切片，返回DataFrame：\n', df.iloc[1:3, 0:2])
print('使用单个标签，返回某一行某一列交叉处的数字：\n', df.iloc[1, 1])
print('使用布尔值列表，返回DataFrame：\n', df.iloc[[False, True, True]])

输出：

    c1  c2  c3  c4
r1   1   2   3   4
r2   5   6   7   8
r3   9  10  11  12
r4  13  14  15  16
使用单个标签，返回Series：
c1    5
c2    6
c3    7
c4    8
Name: r2, dtype: int64
使用标签列表，返回DataFrame：
     c1  c2  c3  c4
r1   1   2   3   4
r3   9  10  11  12
使用切片，返回DataFrame：
     c1  c2
r2   5   6
r3   9  10
使用单个标签，返回某一行某一列交叉处的数字：
 6
使用布尔值列表，返回DataFrame：
     c1  c2  c3  c4
r2   5   6   7   8
r3   9  10  11  12

(3) 属性选择

  直接使用标签选择列。
输入：

df = pd.DataFrame([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12],
                   [13, 14, 15, 16]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df)
print('使用[标签]：\n', df['c2'])
print('使用.标签：\n', df.c3)

输出：

    c1  c2  c3  c4
r1   1   2   3   4
r2   5   6   7   8
r3   9  10  11  12
r4  13  14  15  16
使用[标签]：
 r1     2
r2     6
r3    10
r4    14
Name: c2, dtype: int64
使用.标签：
 r1     3
r2     7
r3    11
r4    15
Name: c3, dtype: int64

2.添加和删除

(1) 列添加和删除

输入：

df = pd.DataFrame([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12],
                   [13, 14, 15, 16]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df)
df['c11'] = pd.Series([11, 22, 33, 44], index=['r2', 'r1', 'r3', 'r4'])  # 直接添加一列
df['c22'] = df['c1'] + df['c3']  # 用另外两列相加新添一列
print('列添加：\n', df)
del df['c2']  # 使用del删除
df.pop('c11')  # 使用pop删除
print('列删除：\n', df)

输出：

    c1  c2  c3  c4
r1   1   2   3   4
r2   5   6   7   8
r3   9  10  11  12
r4  13  14  15  16
列添加：
     c1  c2  c3  c4  c11  c22
r1   1   2   3   4   22    4
r2   5   6   7   8   11   12
r3   9  10  11  12   33   20
r4  13  14  15  16   44   28
列删除：
     c1  c3  c4  c22
r1   1   3   4    4
r2   5   7   8   12
r3   9  11  12   20
r4  13  15  16   28

(2) 行添加和删除

输入：

df = pd.DataFrame([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12],
                   [13, 14, 15, 16]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df)
df.loc['r5'] = [11, 22, 33, 44]
df = df.append(pd.Series([55, 66, 77, 88], index=['c1', 'c2', 'c3', 'c4'], name='r6'))
print('行添加：\n', df)
df = df.drop('r3')  # 使用drop删除
print('行删除：\n', df)

输出：

    c1  c2  c3  c4
r1   1   2   3   4
r2   5   6   7   8
r3   9  10  11  12
r4  13  14  15  16
行添加：
     c1  c2  c3  c4
r1   1   2   3   4
r2   5   6   7   8
r3   9  10  11  12
r4  13  14  15  16
r5  11  22  33  44
r6  55  66  77  88
行删除：
     c1  c2  c3  c4
r1   1   2   3   4
r2   5   6   7   8
r4  13  14  15  16
r5  11  22  33  44
r6  55  66  77  88

（三）基本属性

1. T：转置。
2. axes：返回行、列标签列表。
3. dtypes：返回数据类型。
4. empty：返回系列是否为空。
5. ndim：返回数据维数。
6. shape：返回表示DataFrame的维度的元组。
7. size：返回元素个数。
8. values：将数据帧作为 ndarray 返回。
9. head()：返回前 n 行。n默认为5。
10. tail()：返回后 n 行。n默认为5。
输入：

df = pd.DataFrame([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12],
                   [13, 14, 15, 16]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print('转置:\n', df.T)
print('axes:\n', df.axes)
print('dtype:\n', df.dtypes)
print('empty:', df.empty)
print('ndim:', df.ndim)
print('shape:', df.shape)
print('size:', df.size)
print('values:\n', df.values)
print('head:\n', df.head(2))
print('tail:\n', df.tail(2))

输出：

转置:
     r1  r2  r3  r4
c1   1   5   9  13
c2   2   6  10  14
c3   3   7  11  15
c4   4   8  12  16
axes:
 [Index(['r1', 'r2', 'r3', 'r4'], dtype='object'), Index(['c1', 'c2', 'c3', 'c4'], dtype='object')]
dtype:
 c1    int64
c2    int64
c3    int64
c4    int64
dtype: object
empty: False
ndim: 2
shape: (4, 4)
size: 16
values:
 [[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]
 [13 14 15 16]]
head:
     c1  c2  c3  c4
r1   1   2   3   4
r2   5   6   7   8
tail:
     c1  c2  c3  c4
r3   9  10  11  12
r4  13  14  15  16

四、函数

（一）统计函数

1. count(), 非空值计数

  每行或每列的非空值数量。

  DataFrame.count(self, axis=0, level=None, numeric_only=False)

• axis：0 for index, 1 for columns
• level：整数或字符串，可选参数。如果轴是多重索引，则沿指定层次的轴进行计数。
• numeric_only：布尔值，默认为False。如果为True，只将浮点数、整数或布尔值计数。

输入：

df = pd.DataFrame([[1, np.NaN, 'hehe', True],
                   [5, 6, 'haha', False],
                   [9, 10, 'enhen', True],
                   [13, 14, 'oule', False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.count(numeric_only=True))

输出：

    c1    c2     c3     c4
r1   1   NaN   hehe   True
r2   5   6.0   haha  False
r3   9  10.0  enhen   True
r4  13  14.0   oule  False 

c1    4
c2    3
c4    4
dtype: int64

2. sum(), 求和

  求和。

  DataFrame.sum(self, axis=None, skipna=True, level=None, numeric_only=None, min_count=0, **kwargs)

• axis：0 for index, 1 for columns
• skipna：布尔值，默认为True。计算时是否将 NA/null 纳入计算。
• level：整数或字符串，默认值为None。如果轴是多重索引，则沿指定层次的轴进行计数。
• numeric_only：布尔值，默认为None。如果为True，只将浮点数、整数或布尔值纳入计算。如果为None，则会尽力尝试将所有类型的数据相加。
• min_count：整数，默认值为0。执行求和操作的最少非空值数目，如果非空值的数目小于min_count，则返回结果为空值。
• **kwargs：其他附加的关键字参数。

输入：

df = pd.DataFrame([[1, np.NaN, 'a', True],
                   [5, 6, 'b', False],
                   [9, 10, 'c', True],
                   [13, 14, 'D', False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.sum(numeric_only=True))
print(df.sum(min_count=4))

输出：

    c1    c2 c3     c4
r1   1   NaN  a   True
r2   5   6.0  b  False
r3   9  10.0  c   True
r4  13  14.0  D  False 

c1    28.0
c2    30.0
c4     2.0
dtype: float64

c1      28
c2    None
c3    abcD
c4       2
dtype: object

3. mean(), 平均值

  求平均值。

  DataFrame.mean(self, axis=None, skipna=True, level=None, numeric_only=None, **kwargs)

• axis：0 for index, 1 for columns
• skipna：布尔值，默认为True。计算时是否将 NA/null 纳入计算。
• level：整数或字符串，默认值为None。如果轴是多重索引，则沿指定层次的轴进行计数。
• numeric_only：布尔值，默认为None。如果为True，只将浮点数、整数或布尔值纳入计算。如果为None，则会尽力尝试将所有类型的数据相加。
• **kwargs：其他附加的关键字参数。

输入：

df = pd.DataFrame([[1, np.NaN, 'a', True],
                   [5, 6, 'b', False],
                   [9, 10, 'c', True],
                   [13, 14, 'D', False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.mean(skipna=True))
print(df.mean(skipna=False))

输出：

    c1    c2 c3     c4
r1   1   NaN  a   True
r2   5   6.0  b  False
r3   9  10.0  c   True
r4  13  14.0  D  False 

c1     7.0
c2    10.0
c4     0.5
dtype: float64

c1    7.0
c2    NaN
c4    0.5
dtype: float64

4. median(), 中位数

  求中位数。

  DataFrame.median(self, axis=None, skipna=True, level=None, numeric_only=None, **kwargs)

• axis：0 for index, 1 for columns
• skipna：布尔值，默认为True。计算时是否将 NA/null 纳入计算。
• level：整数或字符串，默认值为None。如果轴是多重索引，则沿指定层次的轴进行计数。
• numeric_only：布尔值，默认为None。如果为True，只将浮点数、整数或布尔值纳入计算。如果为None，则会尽力尝试将所有类型的数据纳入计算。
• **kwargs：其他附加的关键字参数。

输入：

df = pd.DataFrame([[1, np.NaN, 'a', True],
                   [5, 6, 'b', False],
                   [9, 10, 'c', True],
                   [13, 14, 'D', False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.median(skipna=True))
print(df.median(skipna=False))

输出：

    c1    c2 c3     c4
r1   1   NaN  a   True
r2   5   6.0  b  False
r3   9  10.0  c   True
r4  13  14.0  D  False 

c1     7.0
c2    10.0
c4     0.5

dtype: float64
c1    7.0
c2    NaN
c4    0.5
dtype: float64

5. mode(), 众数

  求众数。

  DataFrame.mode(self, axis=0, numeric_only=False, dropna=True)

• axis：0 for index, 1 for columns
• numeric_only：布尔值，默认为False。如果为True，只将浮点数、整数或布尔值纳入计算。
• dropna：布尔值，默认为True。如果为True，则不考虑空值。

输入：

df = pd.DataFrame([[1, np.NaN, 'a', False],
                   [1, np.NaN, 'a', False],
                   [1, 6, 'c', True],
                   [13, 14, 'D', False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.mode(dropna=True))
print(df.mode(dropna=False))

输出：

    c1    c2 c3     c4
r1   1   NaN  a  False
r2   1   NaN  a  False
r3   1   6.0  c   True
r4  13  14.0  D  False 

    c1    c2   c3     c4
0  1.0   6.0    a  False
1  NaN  14.0  NaN    NaN  # 第2列有两个众数，其他列只有1个众数

   c1  c2 c3     c4
0   1 NaN  a  False

6. std(), 标准差

  求标准差。

  DataFrame.std(self, axis=None, skipna=True, level=None, ddof=1, numeric_only=None, **kwargs)

• axis：0 for index, 1 for columns
• skipna：布尔值，默认为True。计算时是否将 NA/null 纳入计算。
• level：整数或字符串，默认值为None。如果轴是多重索引，则沿指定层次的轴进行计数。
• ddof：整数，默认值为1。自由度，除数使用的是N-ddof。（下列公式中样本个数N替换成N-ddof，r表示均值）
  $\sigma (r)=\sqrt{\frac{1}{N}{\sum }_{i=1}^N(x_i-r{)}^2}$
• numeric_only：布尔值，默认为None。如果为True，只将浮点数、整数或布尔值纳入计算。如果为None，则会尽力尝试将所有类型的数据纳入计算。
• **kwargs：其他附加的关键字参数。

输入：

df = pd.DataFrame([[1, np.NaN, 'a', False],
                   [1, np.NaN, 'a', False],
                   [1, 6, 'c', True],
                   [13, 14, 'D', False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.std())

输出：

    c1    c2 c3     c4
r1   1   NaN  a  False
r2   1   NaN  a  False
r3   1   6.0  c   True
r4  13  14.0  D  False 

c1    6.000000
c2    5.656854
c4    0.500000
dtype: float64

7. min(), 最小值

  求最小值。

  DataFrame.min(self, axis=None, skipna=True, level=None, numeric_only=None, **kwargs)

• axis：0 for index, 1 for columns
• skipna：布尔值，默认为True。计算时是否将 NA/null 纳入计算。
• level：整数或字符串，默认值为None。如果轴是多重索引，则沿指定层次的轴进行计数。
• numeric_only：布尔值，默认为None。如果为True，只将浮点数、整数或布尔值纳入计算。如果为None，则会尽力尝试将所有类型的数据纳入计算。
• **kwargs：其他附加的关键字参数。

输入：

df = pd.DataFrame([[1, np.NaN, 'a', False],
                   [1, np.NaN, 'a', False],
                   [1, 6, 'c', True],
                   [13, 14, 'D', False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.min())

输出：

    c1    c2 c3     c4
r1   1   NaN  a  False
r2   1   NaN  a  False
r3   1   6.0  c   True
r4  13  14.0  D  False 

c1        1
c2        6
c3        D
c4    False
dtype: object

8. max(), 最大值

  求最大值。

  DataFrame.max(self, axis=None, skipna=True, level=None, numeric_only=None, **kwargs)

• axis：0 for index, 1 for columns
• skipna：布尔值，默认为True。计算时是否将 NA/null 纳入计算。
• level：整数或字符串，默认值为None。如果轴是多重索引，则沿指定层次的轴进行计数。
• numeric_only：布尔值，默认为None。如果为True，只将浮点数、整数或布尔值纳入计算。如果为None，则会尽力尝试将所有类型的数据纳入计算。
• **kwargs：其他附加的关键字参数。

9. abs(), 绝对值

  求绝对值。本函数仅对数值型元素有效。如果是复数，则返回的是$\sqrt{实{部}^2+虚{部}^2}$
输入：

df = pd.DataFrame([[1, np.NaN, 3 + 4j, False],
                   [-1, np.NaN, -4 + 3j, False],
                   [1, -6, 3, True],
                   [13, 14, 3 - 4j, False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.abs())

输出：

    c1    c2       c3     c4
r1   1   NaN   (3+4j)  False
r2  -1   NaN  (-4+3j)  False
r3   1  -6.0   (3+0j)   True
r4  13  14.0   (3-4j)  False 

    c1   c2 c3 c4
r1   1  NaN  5  0
r2   1  NaN  5  0
r3   1    6  3  1
r4  13   14  5  0

10. prod(), 乘积

  计算各元素的乘积。

  DataFrame.prod(self, axis=None, skipna=True, level=None, numeric_only=None, min_count=0, **kwargs)

• axis：0 for index, 1 for columns
• skipna：布尔值，默认为True。计算时是否将 NA/null 纳入计算。
• level：整数或字符串，默认值为None。如果轴是多重索引，则沿指定层次的轴进行计数。
• numeric_only：布尔值，默认为None。如果为True，只将浮点数、整数或布尔值纳入计算。如果为None，则会尽力尝试将所有类型的数据纳入计算。
• min_count：整数，默认值为0。执行计算的最少非空值数目，如果非空值的数目小于min_count，则返回结果为空值。
• **kwargs：其他附加的关键字参数。

输入：

df = pd.DataFrame([[1, np.NaN, 1 + 1j, False],
                   [-1, np.NaN, -1 + 1j, False],
                   [2, -6, 3, True],
                   [13, 14, 1 - 1j, False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.prod())
print('如果是空的Series，则返回结果为1\n', pd.Series().prod())

输出：

    c1    c2       c3     c4
r1   1   NaN   (1+1j)  False
r2  -1   NaN  (-1+1j)  False
r3   2  -6.0   (3+0j)   True
r4  13  14.0   (1-1j)  False 

c1        -26
c2        -84
c3    (-6+6j)
c4      False
dtype: object

如果是空的Series，则返回结果为1
 1.0

11. cumsum(), 累计和

  计算累计和。

  DataFrame.cumsum(self, axis=None, skipna=True, *args, **kwargs)

• axis：0 for index, 1 for columns
• skipna：布尔值，默认为True。计算时是否将 NA/null 纳入计算。如果整列或者整行都是NA，则返回的结果为NA
• *args, **kwargs：其他附加的关键字参数。附加关键字参数没有实际效果，但是可能与NumPy兼容。

输入：

df = pd.DataFrame([[1, np.NaN, 1 + 1j, False],
                   [-1, np.NaN, -1 + 1j, False],
                   [2, -6, 3, True],
                   [13, 14, 1 - 1j, False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.cumsum())
print(df.cumsum(skipna=False))

输出：

    c1    c2       c3     c4
r1   1   NaN   (1+1j)  False
r2  -1   NaN  (-1+1j)  False
r3   2  -6.0   (3+0j)   True
r4  13  14.0   (1-1j)  False 

    c1   c2      c3     c4
r1   1  NaN  (1+1j)  False
r2   0  NaN      2j      0
r3   2   -6  (3+2j)      1
r4  15    8  (4+1j)      1

    c1   c2      c3     c4
r1   1  NaN  (1+1j)  False
r2   0  NaN      2j      0
r3   2  NaN  (3+2j)      1
r4  15  NaN  (4+1j)      1

12. cumprod(), 累计乘积

  计算累计乘积。

  DataFrame.cumprod(self, axis=None, skipna=True, *args, **kwargs)

• axis：0 for index, 1 for columns
• skipna：布尔值，默认为True。计算时是否将 NA/null 纳入计算。如果整列或者整行都是NA，则返回的结果为NA
• *args, **kwargs：其他附加的关键字参数。附加关键字参数没有实际效果，但是可能与NumPy兼容。

13. cov(), 协方差

  计算协方差。NA/null 不纳入计算。

  DataFrame.cov(self, min_periods=None)

• min_periods：整数，可选参数。参与计算的最小有效值数目。

输入：

df = pd.DataFrame([[1, np.NaN, 1, False],
                   [-1, np.NaN, 1, False],
                   [2, -6, 1, True],
                   [13, 14, 1, False]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df['c1'].cov(df['c2']))
print(df.cov())
print(df.cov(min_periods=3))

输出：

    c1    c2  c3     c4
r1   1   NaN   1  False
r2  -1   NaN   1  False
r3   2  -6.0   1   True
r4  13  14.0   1  False 

110.0

            c1     c2   c3         c4
c1   39.583333  110.0  0.0  -0.583333
c2  110.000000  200.0  0.0 -10.000000
c3    0.000000    0.0  0.0   0.000000
c4   -0.583333  -10.0  0.0   0.250000

           c1  c2   c3        c4
c1  39.583333 NaN  0.0 -0.583333
c2        NaN NaN  NaN       NaN
c3   0.000000 NaN  0.0  0.000000
c4  -0.583333 NaN  0.0  0.250000

14. pct_change(), 环比

  计算环比，即每一个元素与上一元素的变化百分比。

  DataFrame.pct_change(self, periods=1, fill_method=‘pad’, limit=None, freq=None, **kwargs)

• periods：整数，默认值为1。即返回每一个元素与前periods个元素的变化百分比，默认值为1，即每一个元素与上一个元素的变化百分比。
• fill_method：字符串，默认值为’pad’。如何填充NA值。
• limit：整数，默认值为None。停止前要填充的NA数量。
• **kwargs：其他附加的关键字参数。

输入：

df = pd.DataFrame([[1, np.NAN, 1, 2],
                   [2, 1, 2, 6],
                   [3, np.NAN, 3, 5],
                   [4, 5, 6, 3],
                   [5, 2, 7, 9]], index=['r1', 'r2', 'r3', 'r4', 'r5'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.pct_change())
print(df.pct_change(periods=2))

输出：

    c1   c2  c3  c4
r1   1  NaN   1   2
r2   2  1.0   2   6
r3   3  NaN   3   5
r4   4  5.0   6   3
r5   5  2.0   7   9 

          c1   c2        c3        c4
r1       NaN  NaN       NaN       NaN
r2  1.000000  NaN  1.000000  2.000000
r3  0.500000  0.0  0.500000 -0.166667
r4  0.333333  4.0  1.000000 -0.400000
r5  0.250000 -0.6  0.166667  2.000000

          c1   c2        c3   c4
r1       NaN  NaN       NaN  NaN
r2       NaN  NaN       NaN  NaN
r3  2.000000  NaN  2.000000  1.5
r4  1.000000  4.0  2.000000 -0.5
r5  0.666667  1.0  1.333333  0.8

15. pct_corr(), 相关系数

  计算两个数列之间的相关系数。

  DataFrame.corr(self, method=‘pearson’, min_periods=1)

• method：计算相关系数的方法。可选 ‘pearson’、‘kendall’、‘spearman’、callable
• min_periods：整数，可选参数。得到结果所需的最小的列数，仅Pearson和Spearman有用。

输入：

df = pd.DataFrame([[1, 5, 1, 2],
                   [2, 6, 2, 6],
                   [3, 7, 3, 5],
                   [4, 8, 6, 3]], index=['r1', 'r2', 'r3', 'r4'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print('pearson:\n', df.corr())
print('kendall:\n', df.corr(method='kendall'))
print('spearman:\n', df.corr(method='spearman'))

输出：

    c1  c2  c3  c4
r1   1   5   1   2
r2   2   6   2   6
r3   3   7   3   5
r4   4   8   6   3 

pearson:
           c1        c2        c3        c4
c1  1.000000  1.000000  0.956183  0.141421
c2  1.000000  1.000000  0.956183  0.141421
c3  0.956183  0.956183  1.000000 -0.084515
c4  0.141421  0.141421 -0.084515  1.000000
kendall:
      c1   c2   c3   c4
c1  1.0  1.0  1.0  0.0
c2  1.0  1.0  1.0  0.0
c3  1.0  1.0  1.0  0.0
c4  0.0  0.0  0.0  1.0
spearman:
      c1   c2   c3   c4
c1  1.0  1.0  1.0  0.2
c2  1.0  1.0  1.0  0.2
c3  1.0  1.0  1.0  0.2
c4  0.2  0.2  0.2  1.0

（二）排序函数

1. sort_index(), 对标签排序

  对标签(index)排序。

  DataFrame.sort_index(self, axis=0, level=None, ascending=True, inplace=False, kind=‘quicksort’, na_position=‘last’, sort_remaining=True)

• axis：0 for index, 1 for columns
• level：指定排序的轴level。（多重索引）
• ascending：布尔值，默认值True。True为升序，False为降序(descending)
• inplace：布尔值，默认值False。是否替代原DataFrame
• kind：{‘quicksort’, ‘mergesort’, ‘heapsort’}, 默认值 ‘quicksort’。排序算法。‘mergesort’ 是唯一的稳定算法。对于DataFrame，仅在针对单个列排序时本参数有效。
• na_position：{‘first’, ‘last’}, 默认值 ‘last’。将NA值放在前面还是后面，对多重索引无效。
• sort_remaining：布尔值，默认值True。多重索引时，在对指定Level排序后，对其他Level进行排序。

输入：

df = pd.DataFrame([[1, 5, 1, 2],
                   [2, 9, 3, 5],
                   [5, 7, 2, 5],
                   [4, 8, 6, 3]], index=['d', 'a', 'b', 'c'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
df.sort_index(axis=1, ascending=False, inplace=True)
print(df)

输出：

   c1  c2  c3  c4
d   1   5   1   2
a   2   9   3   5
b   5   7   2   5
c   4   8   6   3 

   c4  c3  c2  c1
d   2   1   5   1
a   5   3   9   2
b   5   2   7   5
c   3   6   8   4  # 仅是对标签进行排序，不是对值排序  

2. sort_values(), 按值排序

  按值排序。

  DataFrame.sort_values(self, by, axis=0, ascending=True, inplace=False, kind=‘quicksort’, na_position=‘last’)

• by：字符串，或者字符串列表。筛选的行或列。
• axis：0 for index, 1 for columns
• ascending：布尔值或者布尔值列表，默认值True。True为升序，False为降序(descending)。如果是布尔值列表，则与by参数要一一对应。
• inplace：布尔值，默认值False。是否替代原DataFrame
• kind：{‘quicksort’, ‘mergesort’, ‘heapsort’}, 默认值 ‘quicksort’。排序算法。‘mergesort’ 是唯一的稳定算法。对于DataFrame，仅在针对单个列排序时本参数有效。
• na_position：{‘first’, ‘last’}, 默认值 ‘last’。将NA值放在前面还是后面，对多重索引无效。

输入：

df = pd.DataFrame([[1, 5, 1, 2],
                   [2, 9, 3, 5],
                   [5, 7, 2, 5],
                   [4, 7, 6, 3]], index=['d', 'a', 'b', 'c'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
df.sort_values(by=['c2', 'c3'], ascending=False, inplace=True)
print(df)

输出：

   c1  c2  c3  c4
d   1   5   1   2
a   2   9   3   5
b   5   7   2   5
c   4   7   6   3 

   c1  c2  c3  c4
a   2   9   3   5
c   4   7   6   3
b   5   7   2   5
d   1   5   1   2  # 此处先按c2降序后，相同值的地方又按c3降序

3. rank(), 排名

  为元素数组中的每个元素生成排名。如果相同，则分配平均等级。

  DataFrame.rank(self, axis=0, method=‘average’, numeric_only=None, na_option=‘keep’, ascending=True, pct=False)

• axis：0 for index, 1 for columns
• method：{‘average’, ‘min’, ‘max’, ‘first’, ‘dense’}, 默认值 ‘average’。值相同时如何排名。average按排名的平均值；min按最小的排名；max按最大的排名；first按出现顺序排名；dense和min差不多，但是排名通常只增加1，即相同值只占一个排名位置
• numeric_only：布尔值，可选参数。是否只对数值列排名。
• na_position：{‘keep’, ‘top’, ‘bottom’}, 默认值 ‘keep’。NA值如何排名。keep对NA排名为NA；top对NA排名为最高；bottom对NA排名为最低
• ascending：布尔值，默认值True。True为升序，False为降序(descending)
• pct：布尔值，默认值False。是否以百分比形式返回排名

输入：

df = pd.DataFrame([[1, 5, 1, 2],
                   [2, 9, 3, 5],
                   [5, 7, 2, 5],
                   [4, 7, 6, 3]], index=['d', 'a', 'b', 'c'], columns=['c1', 'c2', 'c3', 'c4'])
print(df, '\n')
print(df.rank())
print(df.rank(method='min'))
print(df.rank(method='first'))
print(df.rank(method='dense'))
print(df.rank(pct=True))

输出：

   c1  c2  c3  c4
d   1   5   1   2
a   2   9   3   5
b   5   7   2   5
c   4   7   6   3 

    c1   c2   c3   c4
d  1.0  1.0  1.0  1.0
a  2.0  4.0  3.0  3.5
b  4.0  2.5  2.0  3.5
c  3.0  2.5  4.0  2.0

    c1   c2   c3   c4
d  1.0  1.0  1.0  1.0
a  2.0  4.0  3.0  3.0
b  4.0  2.0  2.0  3.0
c  3.0  2.0  4.0  2.0  # 第2列可以看到第2行的9排名为4

    c1   c2   c3   c4
d  1.0  1.0  1.0  1.0
a  2.0  4.0  3.0  3.0
b  4.0  2.0  2.0  4.0
c  3.0  3.0  4.0  2.0

    c1   c2   c3   c4
d  1.0  1.0  1.0  1.0
a  2.0  3.0  3.0  3.0
b  4.0  2.0  2.0  3.0
c  3.0  2.0  4.0  2.0 # 第2列可以看到第2行的9排名为3，dense方法的排名，相同值只占1位

     c1     c2    c3     c4
d  0.25  0.250  0.25  0.250
a  0.50  1.000  0.75  0.875
b  1.00  0.625  0.50  0.875
c  0.75  0.625  1.00  0.500

（三）文本函数

1. lower(), 转小写

  Series.str.lower(self)

2. upper(), 转大写

  Series.str.upper(self)

3. len(), 字符长度

  Series.str.len(self)

4. strip(), 删除首尾指定字符

  Series.str.strip(self, to_strip=None)

• to_strip：字符串或者None，默认为None。要删除的字符系列，如果是None，则默认删除空格。

输入：

s = pd.Series(['a.', '1bb', '2 cccc '])
print(s.str.strip())
print(s.str.strip('12.'))

输出：

0        a.
1       1bb
2    2 cccc
dtype: object

0         a
1        bb
2     cccc 
dtype: object

5. split(), 拆分

  按指定分隔符拆分。

  Series.str.split(self, pat=None, n=-1, expand=False)

• pat：字符串，可选参数。指定的分隔符，字符串或者正则表达式，如果没有指定，则默认分隔符为空格
• n：整数，默认值-1。限定拆分的次数，None、0、-1表示不限制次数，完全拆分
• expand：布尔值，默认值False。是否将结果拓展为多列。值为True时，返回结果是一个DataFrame；值为False时，返回结果是一个Series

输入：

s = pd.Series(['a.b.c.d', 'b bb', '2 c.c.cc'])
print(s.str.split())
print(s.str.split('.', n=1))
print(s.str.split('.', n=2, expand=True))

输出：

0      [a.b.c.d]
1        [b, bb]
2    [2, c.c.cc]
dtype: object

0     [a, b.c.d]
1         [b bb]
2    [2 c, c.cc]
dtype: object

      0     1     2
0     a     b   c.d
1  b bb  None  None
2   2 c     c    cc

6. cat(), 连结

  按指定分隔符连结。

  Series.str.cat(self, others=None, sep=’’, na_rep=None, join=None)

• others：Series, Index, DataFrame, np.ndarray or list-like。必须跟原Series长度相同。
• sep：字符串，默认值为 ‘’ 。连结后，使用的分隔符。
• na_rep：字符串或None，默认值为None。缺失值如何填充。如果na_rep为None，others也为None，则缺失值就会被省略；如果na_rep为None，而others不为None，则这一行为NA值。
• join：{‘left’, ‘right’, ‘outer’, ‘inner’}, 默认值为None。指定连结的方式。others的index和原Series不一样时有效果。

输入：

s = pd.Series(['1', '2', '3', '5'])
print(s.str.cat())
print(s.str.cat(list('abcd')))
print(s.str.cat(list('abcd'), sep='@'))
print(s.str.cat(['a', np.NaN, 'c', 'd']))
print(s.str.cat(['a', np.NaN, 'c', 'd'], na_rep='#'))
t = pd.Series(['a', np.NaN, 'c', 'd'], index=[3, 0, 4, 2])
print('left:\n',s.str.cat(t, na_rep='#', join='left'))
print('right:\n',s.str.cat(t, na_rep='#', join='right'))
print('inner:\n',s.str.cat(t, na_rep='#', join='inner'))
print('outer:\n',s.str.cat(t, na_rep='#', join='outer'))

输出：

1235

0    1a
1    2b
2    3c
3    5d
dtype: object

0    1@a
1    2@b
2    3@c
3    5@d
dtype: object

0     1a
1    NaN
2     3c
3     5d
dtype: object

0    1a
1    2#
2    3c
3    5d
dtype: object

left:
 0    1#
1    2#
2    3d
3    5a
dtype: object
right:
 3    5a
0    1#
4    #c
2    3d
dtype: object
inner:
 0    1#
2    3d
3    5a
dtype: object
outer:
 0    1#
1    2#
2    3d
3    5a
4    #c
dtype: object

7. get_dummies(), 哑变量

  Series.str.get_dummies(self, sep=’|’)

• sep：字符串，默认为 ‘|’。分隔符

输入：

s = pd.Series(['a|c', 'b', 'c', 'a|b'])
print(s.str.get_dummies())

输出：

   a  b  c
0  1  0  1
1  0  1  0
2  0  0  1
3  1  1  0

8. contains(), 是否包含

  检查Series中是否包含指定正则表达式的内容。

  Series.str.contains(self, pat, case=True, flags=0, na=nan, regex=True)

• pat：字符串。字符序列或者正则表达式。
• case：布尔值，默认值为True。是否大小写敏感。
• flags：整数，默认值为0。正则表达式的flags，例如re.IGNORECASE。
• na：默认值NaN。缺失值用什么填充。
• regex：布尔值，默认为True。值为True时，确保pat是一个正则表达式；值为False，将pat视为字符串。

输入：

s = pd.Series(['aBd', 'aC', 'bbb', 'bc'])
print(s.str.contains('c'))
print(s.str.contains('c', case=False))

输出：

0    False
1    False
2    False
3     True
dtype: bool

0    False
1     True
2    False
3     True
dtype: bool

9. replace(), 替换

  按指定正则表达式进行替换。

  Series.str.replace(self, pat, repl, n=-1, case=None, flags=0, regex=True)

• pat：字符串。字符序列或者正则表达式。
• repl：字符串或callable。将目标替换成repl。
• n：整数，默认值为-1（全部替换）。替换的个数。
• case：布尔值，默认值为True。是否大小写敏感。
• flags：整数，默认值为0。正则表达式的flags，例如re.IGNORECASE。
• regex：布尔值，默认为True。值为True时，确保pat是一个正则表达式；值为False，将pat视为字符串。

输入：

s = pd.Series(['aBd', 'aC', 'bbb', 'bc'])
print(s.str.replace('c', '1'))
print(s.str.replace('c', '2', case=False))

输出：

0    aBd
1     aC
2    bbb
3     b1
dtype: object

0    aBd
1     a2
2    bbb
3     b2
dtype: object

10. repeat(), 重复

  Series.str.repeat(self, repeats)

• repeats：整数或整数列表。重复次数。

输入：

s = pd.Series(['a', 'b', 'c', 'd'])
print(s.str.repeat(repeats=2))
print(s.str.repeat(repeats=[1, 2, 3, 4]))

输出：

0    aa
1    bb
2    cc
3    dd
dtype: object

0       a
1      bb
2     ccc
3    dddd
dtype: object

11. count(), 计数

  指定模式出现的次数。

  Series.str.count(self, pat, flags=0, **kwargs)

• pat：字符串。正则表达式。
• flags：整数，默认值为0。正则表达式的flags，例如re.IGNORECASE。

输入：

s = pd.Series(['ab1', 'bb', 'bc3', 'd'])
print(s.str.count('b'))
print(s.str.count('\d'))

输出：

0    1
1    2
2    1
3    0
dtype: int64

0    1
1    0
2    1
3    0
dtype: int64

12. find(), 查找

  返回指定模式第一次出现的位置。

  Series.str.find(self, sub, start=0, end=None)

• sub：字符串。需要搜索的子字符串。
• start：整数。开始搜索的位置。
• end：整数。结束搜索的位置。

输入：

s = pd.Series(['ab1', 'bb', 'c3b', 'd'])
print(s.str.find('b'))
print(s.str.find('b', start=1, end=2))

输出：

0    1
1    0
2    2
3   -1
dtype: int64

0    1
1    1
2   -1
3   -1
dtype: int64

13. findall(), 查找

  查找所有符合模式的字符串，形成列表。

  Series.str.findall(self, pat, flags=0, **kwargs)

• pat：字符串。正则表达式。
• flags：整数，默认值为0。正则表达式的flags，例如re.IGNORECASE。

输入：

s = pd.Series(['ab1', 'bb', 'c3b', 'd'])
print(s.str.findall('b'))

输出：

0       [b]
1    [b, b]
2       [b]
3        []
dtype: object

（四）可视化函数

1. line(), 折线图

  DataFrame.plot.line(self, x=None, y=None, **kwargs)

• x：可选参数。x轴所使用的列，既可使用位置下标，也可使用标签。缺省时，使用的是DataFrame的index序列。
• y：可选参数。y轴所使用的列，既可使用位置下标，也可使用标签。缺省时，使用的是DataFrame的所有数值列。

输入：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

df = pd.DataFrame([[1, 3],
                   [3, 8],
                   [4, 6],
                   [10, 12]], index=['a', 'b', 'c', 'd'], columns=['X', 'Y'])
print(df)
df.plot.line()
df.plot.line(x='X', y='Y')
plt.show()  # PyCharm中，必须加上这一项才会显示图片

输出：

2. bar(), 条形图

  DataFrame.plot.bar(self, x=None, y=None, **kwargs)

• x：可选参数。x轴所使用的列，既可使用位置下标，也可使用标签。缺省时，使用的是DataFrame的index序列。
• y：可选参数。y轴所使用的列，既可使用位置下标，也可使用标签。缺省时，使用的是DataFrame的所有数值列。

输入：

df = pd.DataFrame([[1, 3],
                   [3, 8],
                   [4, 6],
                   [10, 12]], index=['a', 'b', 'c', 'd'], columns=['X', 'Y'])
print(df)
df.plot.bar(rot=0)  # 实测要有rot=0，横坐标才不会倒着
df.plot.bar(rot=0, subplots=True)  # 拆分显示
df.plot.bar(rot=0, stacked=True)  # 堆积
df.plot.bar(x='X', y='Y')  # 没有rot=0，横坐标会倒着
plt.show()

输出：

3. barh(), 水平条形图

  DataFrame.plot.barh(self, x=None, y=None, **kwargs)

• x：可选参数。x轴所使用的列，既可使用位置下标，也可使用标签。缺省时，使用的是DataFrame的index序列。
• y：可选参数。y轴所使用的列，既可使用位置下标，也可使用标签。缺省时，使用的是DataFrame的所有数值列。

输入：

df = pd.DataFrame([[1, 3],
                   [3, 8],
                   [4, 6],
                   [10, 12]], index=['a', 'b', 'c', 'd'], columns=['X', 'Y'])
print(df)
df.plot.barh()
plt.show()

输出：

4. hist(), 直方图

  DataFrame.plot.hist(self, by=None, bins=10, **kwargs)

• by：字符串，可选参数。分组的列。（这个参数没有弄懂）
• bins：整数，默认值为10。直方图的箱数。

输入：

df = pd.DataFrame(np.random.randint(1, 7, 10000), columns=['a'])
df['b'] = df['a'] + np.random.randint(1, 7, 10000)
df.plot.hist(bins=12, alpha=0.5)  # 透明度0.5
plt.show()

输出：

5. box(), 箱型图

输入：

df = pd.DataFrame([[1, 3, 4, 7],
                   [3, 7, 4, 9],
                   [4, 5, 9, 2],
                   [7, 9, 2, 1]], columns=['A', 'B', 'C', 'D'])
print(df)
df.plot.box()
plt.show()

输出：

6. area(), 面积图

  DataFrame.plot.area(self, x=None, y=None, stacked=True, **kwargs)

• x：可选参数。x轴所使用的列，既可使用位置下标，也可使用标签。缺省时，使用的是DataFrame的index序列。
• y：可选参数。y轴所使用的列，既可使用位置下标，也可使用标签。缺省时，使用的是DataFrame的所有列。
• stacked：布尔值，默认为True。是否累计。

输入：

df = pd.DataFrame([[1, 3, 4, 7],
                   [3, 7, 4, 9],
                   [4, 5, 9, 2],
                   [7, 9, 2, 1]], columns=['A', 'B', 'C', 'D'])
print(df)
df.plot.area()
df.plot.area(y=['A'])
df.plot.area(stacked=False)
plt.show()

输出：
第一个图是累计的，可以看到B列在图上的值是B列的值加上A列的值。

7. scatter(), 散点图

  DataFrame.plot.scatter(self, x, y, s=None, c=None, **kwargs)

• x：整数或字符串。横轴使用的列。
• y：整数或字符串。纵轴使用的列。
• s：数字或数字列表，可选参数。每个点的大小。如果是一个数字，则是设置所有点的大小；如果是一个列表，则是设置对应每个点的大小。
• c：字符串、整数或列表，可选参数。每个点的颜色。与s参数的设置方法类似，可以使用颜色名字例如’red’，也可以使用RGB编码例如’#a98d19’。

输入：

df = pd.DataFrame([[1, 3, 4, 7],
                   [3, 6, 4, 9],
                   [4, 8, 9, 2],
                   [7, 13, 2, 1]], columns=['A', 'B', 'C', 'D'])
df.plot.scatter(x='A', y='B', s=[10, 30, 50, 100], c='green')
plt.show()

输出：

8. pie(), 饼状图

  DataFrame.plot.pie(self, y=None, subplots=None, **kwargs)

• y：整数或标签，可选参数。用于绘图的列，如果本参数没有设置，则subplots=True必须传递。

输入：

df = pd.DataFrame([[1, 3, 4, 7],
                   [3, 6, 4, 9],
                   [4, 8, 9, 2],
                   [7, 13, 2, 1]], index=['r1', 'r2', 'r3', 'r4'], columns=['A', 'B', 'C', 'D'])
df.plot.pie(y='A')
df.plot.pie(subplots=True)
plt.show()

输出：

（五）IO函数

1. read_csv()

  pandas.read_csv(filepath_or_buffer: Union[str, pathlib.Path, IO[~AnyStr]], sep=’,’, delimiter=None, header=‘infer’, names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, skipfooter=0, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False, infer_datetime_format=False, keep_date_col=False, date_parser=None, dayfirst=False, cache_dates=True, iterator=False, chunksize=None, compression=‘infer’, thousands=None, decimal=b’.’, lineterminator=None, quotechar=’"’, quoting=0, doublequote=True, escapechar=None, comment=None, encoding=None, dialect=None, error_bad_lines=True, warn_bad_lines=True, delim_whitespace=False, low_memory=True, memory_map=False, float_precision=None)

2. read_excel()

  pandas.read_excel(io, sheet_name=0, header=0, names=None, index_col=None, usecols=None, squeeze=False, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skiprows=None, nrows=None, na_values=None, keep_default_na=True, verbose=False, parse_dates=False, date_parser=None, thousands=None, comment=None, skip_footer=0, skipfooter=0, convert_float=True, mangle_dupe_cols=True, **kwds)

参考文献：
[1] https://www.yiibai.com/pandas
[2] https://pandas.pydata.org/pandas-docs/stable/