从头到尾都是手码的，文中的所有示例也都是在Pycharm中运行过的，自己整理笔记的最大好处在于可以按照自己的思路来构建框架，等到将来在需要的时候能够以最快的速度看懂并应用=_=
注：为方便表述，本章设s为pandas.core.series.Series的一个实例化对象，设df为pandas.core.frame.DataFrame的一个实例化对象
1. Pandas简介
Pandas是基于NumPy的python数据分析库，最初被作为金融数据分析工具而开发出来，因此Pandas为时间序列分析提供了很好的支持。 Pandas的名称来自于面板数据（panel data）和python数据分析（data analysis）。panel data是经济学中关于多维数据集的一个术语，在Pandas中也提供了Panel的数据类型（注：在最新版本的Pandas中已将该数据类型删除）。
Pandas是构建在Numpy的基础上的，所以我们在加载pandas之前，最好先把Numpy也加载进来：
import numpy as np
import pandas as pd
2. Pandas中的三大数据类型
在Pandas中有下面三种数据结构：Series、DataFrame、Panel。
| 数据结构 | 维数 | 说明 |
|---|---|---|
| Series | 1 | |
| Dataframe | 2 | 是Series的容器 |
| Panel | 3 | 是Dataframe的容器（注：在最新版本的Pandas中已将Panel数据类型删除） |
3. Series
Series具有一维的数据结构，它拥有一列index和一列values，每个Series都是pandas.core.series.Series的一个实例化对象。
本节仅讨论具有一维index结构的Series，关于具有多维index结构的Series，见本章“13.层次化索引”
（1）创建Series
语法：pd.Series(data=None, index=None, dtype=None, name=None)
参数：
data：数据，它可以是一维list、dict、range()或一维numpy.ndarray。data的默认值为None，此时会创建一个空的Series([])
-
index：索引，默认值为None（当data为非dict类型时，默认索引为0、1、2……；当data为dict类型时，默认索引为dict的键）
可以使用一个list、tuple、range()或numpy.ndarray自定义索引。注意：
① index长度必须与data长度相等，否则报错；
② 当data为dict类型时，不可以再使用自定义index，否则自定义index不仅会覆盖掉字典的键，还会让Series的所有值变为NaN
③ 默认的index（0、1、2……）称为position（位置），自定义的index称为label（标签）。未定义index时，只能通过position取值；定义index后，既可以通过position取值，也可以通过label取值。
④ 本节仅讨论具有一维index结构的Series，关于具有多维index结构的Series，见本章“13.层次化索引”
dtype：数据类型
name：Series的名字
注意：和DataFrame不同，Series没有columns参数！
# 通过list和numpy.ndarray创建Series
import numpy as np
import pandas as pd
s1 = pd.Series([1,2,3])
s2 = pd.Series(np.array([1,2,3]), index=['a','b','c'], name='MySeries')
print(s1); print('===========')
print(type(s1)); print('===========')
print(s2); print('===========')
print(type(s2))
执行结果：
0 1
1 2
2 3
dtype: int64
===========
<class 'pandas.core.series.Series'>
===========
a 1
b 2
c 3
Name: MySeries, dtype: int32
===========
<class 'pandas.core.series.Series'>
# 通过dict创建Series
import numpy as np
import pandas as pd
s1 = pd.Series({'a':1,'b':2,'c':3})
s2 = pd.Series({'a':1,'b':2,'c':3}, index=['A','B','C']) # 错误的定义方式
print(s1); print('===========')
print(type(s1)); print('===========')
print(s2); print('===========')
print(type(s2))
执行结果：
a 1
b 2
c 3
dtype: int64
===========
<class 'pandas.core.series.Series'>
===========
A NaN
B NaN
C NaN
dtype: float64
===========
<class 'pandas.core.series.Series'>
（2）Series的向量化和广播
① 向量化： Series与一维对象进行计算
这个计算有个前提，即一维对象的长度等于Series的长度，该一维对象可以是list, numpy.ndarray……在满足这个前提的情况下（不满足则报错），会进行元素级操作，相同位置的元素按照某种运算规则进行运算，并返回一个与原Series索引相同、相同长度的Series
import numpy as np
import pandas as pd
s = pd.Series([10,11,12],index=['a','b','c'])
arr = np.array([9,11,13])
print(s + arr)
print('===========')
print(s > arr)
执行结果：
a 19
b 22
c 25
dtype: int64
===========
a True
b False
c False
dtype: bool
② 广播：Series与数字进行计算
对于Series与数字进行的+、-、*、/、**、//、%、>、<、>=、<=、==、!=等运算，会将这个Series中的每一个值均与这个数字进行计算，并用这些结果组成一个与原Series结构相同的Series
import numpy as np
import pandas as pd
s = pd.Series([10,11,12],index=['a','b','c'])
print(s+2)
print('===========')
print(s>11)
执行结果：
a 12
b 13
c 14
dtype: int64
===========
a False
b False
c True
dtype: bool
③ Series与多维对象进行计算（不支持）
Series不支持与多维对象进行计算，即一个多维numpy.ndarray不支持Series对其进行广播
import numpy as np
import pandas as pd
arr = np.array([[9,11,13],[8,15,10],[7,6,16]])
s = pd.Series([10,11,12])
print(arr + s)
print(arr > s)
执行结果：报错
（3）Series的索引和切片
s[0]：基于position（位置）的索引
s['a']：基于label（标签）的索引
s[1:3]：基于position的切片，顾前不顾后
s['b':'d']：基于label的切片，前后都包含
s[s>5]：先通过广播获得值为bool的Series，然后再筛选其中值为True的项构建新的Series（类似布尔值索引）
s[[3,1,2]]、s[['e','b','d']]：通过list实现不连续索引（类似花式索引）
s.loc[]：与df.loc[]用法相似
s.iloc[]：与df.iloc[]用法相似
import numpy as np
import pandas as pd
s = pd.Series(range(10,15),index=['a','b','c','d','e'])
print(s); print('===========')
print(s[2]); print('===========')
print(s['c']); print('===========')
print(s[1:3]); print('===========') # 顾前不顾后
print(s['b':'d']); print('===========') # 前后都包含
print(s[s>12]); print('===========')
print(s[[3,1,2]]); print('===========')
print(s[['e','b','d']])
执行结果：
a 10
b 11
c 12
d 13
e 14
dtype: int64
===========
12
===========
12
===========
b 11
c 12
dtype: int64
===========
b 11
c 12
d 13
dtype: int64
===========
d 13
e 14
dtype: int64
===========
d 13
b 11
c 12
dtype: int64
===========
e 14
b 11
d 13
dtype: int64
（4）Series的常用属性
注意：Series没有columns属性！
s.values：返回Series的所有值，数据类型为numpy.ndarray
s.index：返回Series的所有索引，数据类型为pandas.core.indexes.base.Index
s.name：Series的名字（可以赋值修改）
s.index.name：索引的名字（可以赋值修改）
（5）Series的常用方法
s.__len__()和len(s)：返回s的长度（int类型）
s.apply(func)和s.map(func)：将s中的每个元素分别传递给func作为其参数并执行func()，并将每次func()的返回值组成一个结构相同的新的Series，作为s.apply()或s.map()整体的返回值。代码示例见下面例2。所有apply()、applymap()、map()的对比见本章“二、Pandas模块 - 10. DataFrame对象的方法和Pandas模块的方法 - （5）其他重要方法 - ② df.applymap()”
s1.corr(s2)：计算两个Series的Pearson相关系数，返回一个float
s1.cov(s2)：计算两个Series的协方差，返回一个float
s.dropna()：删除s中的NaN
s.head(n)：返回s的至多前n项索引与值组成的Series，n默认为5。此方法用于快速预览，不会修改s本身
s.idxmin()和s.idxmax()：反查s中最小值（最大值）所对应的索引。注意：s.argmin()和s.argmax()两个方法已弃用
s.isin(list)：判断s中的每个元素是否在list中，返回一个与s结构相同但是由布尔值组成的Series
s.isna()和s.isnull()：与df.isna()和df.isnull()类似
s.notna()：与df.notna()类似
s.ptp()：计算s的极差（最大值减最小值），返回float（注意：DataFrame无此方法！）
s.replace('替换前的值','替换后的值',inplace=False)：将s中的值进行替换，当同时进行多个替换时，可以使用字典将替换前的值、替换后的值组成键值对，即s.replace({'旧1':'新1','旧2':'新2'...},inplace=False)
s.sort_values()：按值进行排序，类比df.sort_values()，由于Series只有一列，所以不用输入by=
s.str.字符串方法()：将s中的每个字符串按照指定的方法进行处理并组成一个新的Series，代码示例见下面例3
s.tail(n)：返回s的至多后n项索引与值组成的Series，n默认为5。此方法用于快速预览，不会修改s本身
s.tolist()：将s转换为list格式（不直接修改s，须定义一个变量来接收）（注意：DataFrame无此方法！）
s.unstack()：对层次化索引的Series进行变形（行标签与列标签的转换），详见本章“13.层次化索引 - （3）使用unstack()和stack()和DataFrame对层次化索引的Series进行变形（行标签与列标签的转换）”
s.value_counts()：统计s中的每个值出现的次数，返回一个Series（注意：numpy.ndarray和DataFrame都无此方法！）
s.var()：计算Series的方差，返回一个float
# 例1
import numpy as np
import pandas as pd
s = pd.Series([10,12,11,11,12],index=['a','b','c','d','e'],name='旧名字')
s.name='新名字'
s.index.name = '索引'
print(s); print('===========')
print(s.values,type(s.values)); print('===========')
print(s.index,type(s.index)); print('===========')
print(s.name); print('===========')
print(s.index.name); print('===========')
print(s.head(2)); print('===========')
print(s.tail(2)); print('===========')
print(s.__len__(),len(s),type(len(s))); print('===========')
print(s.tolist(),type(s.tolist())); print('===========')
print(s.value_counts(),type(s.value_counts())); print('===========')
print(s.isin([5,6,7,11,15,16,17]),type(s.isin([5,6,7,11,15,16,17]))); print('===========')
print(s.ptp())
执行结果：
索引
a 10
b 12
c 11
d 11
e 12
Name: 新名字, dtype: int64
===========
[10 12 11 11 12] <class 'numpy.ndarray'>
===========
Index(['a', 'b', 'c', 'd', 'e'], dtype='object', name='索引') <class 'pandas.core.indexes.base.Index'>
===========
新名字
===========
索引
===========
索引
a 10
b 12
Name: 新名字, dtype: int64
===========
索引
d 11
e 12
Name: 新名字, dtype: int64
===========
5 5 <class 'int'>
===========
[10, 12, 11, 11, 12] <class 'list'>
===========
12 2
11 2
10 1
Name: 新名字, dtype: int64 <class 'pandas.core.series.Series'>
===========
索引
a False
b False
c True
d True
e False
Name: 新名字, dtype: bool <class 'pandas.core.series.Series'>
===========
2
# 例2：Series.apply(func)和Series.map(func)
import numpy as np
import pandas as pd
s1 = pd.Series([10,20,30], index=['t1','t2','t3'])
s2 = s1.apply(lambda x:x+1)
s3 = s1.map(lambda x:x+2)
print(s1); print('===========')
print(s2); print('===========')
print(s3)
执行结果：
t1 10
t2 20
t3 30
dtype: int64
===========
t1 11
t2 21
t3 31
dtype: int64
===========
t1 12
t2 22
t3 32
dtype: int64
# 例3：s.str.字符串方法()
import numpy as np
import pandas as pd
s1 = pd.Series(['a_b','c_d'],index=['t1','t2'])
s2 = s1.str.replace('_','')
s3 = s1.str.startswith('a')
print(s1); print('===========')
print(s2); print('===========')
print(s3)
执行结果：
t1 a_b
t2 c_d
dtype: object
===========
t1 ab
t2 cd
dtype: object
===========
t1 True
t2 False
dtype: bool
4. DataFrame的创建
DataFrame具有二维的数据结构，它拥有一列index和若干列values，每个DataFrame都是pandas.core.frame.DataFrame的一个实例化对象。
本节仅讨论具有一维index结构的DataFrame，关于具有多维index结构的DataFrame，见本章“13.层次化索引”
语法：pd.DataFrame(data=None, index=None, columns=None, dtype=None)
参数：
data：数据，它可以是dict、一维或二维list、一维或二维numpy.ndarray。当data是一维list或一维numpy.ndarray时，pd.DataFrame()会将其变为一个2行1列的列向量（可参见本章“DataFrame对象的常用属性和方法部分的（4）df.shape中的例子”）。data的默认值为None，此时会创建一个空的DataFrame
-
index：行索引，默认值为None（默认行索引为0、1、2……）
可以使用list自定义行索引，注意：
① index长度必须与data的行数相等，否则报错；
② 当data为dict类型时，不可以在pd.DataFrame()括号里自定义index，否则会让所有数据类型为Series的列的值都变为NaN。正确的方式有两种：一是在df定义完成后另写一行
df.index=[...]；二是在定义字典时值都用Series类型，并给每个Series都单独定义index=[...]③ 默认的index（0、1、2……）称为position（位置），自定义的index称为label（标签）。未定义index时，只能通过position取值；定义index后，既可以通过position取值，也可以通过label取值。
④ 本节仅讨论具有一维index结构的DataFrame，关于具有多维index结构的DataFrame，见本章“13.层次化索引”
-
columns：列索引，默认值为None（当data为非dict类型时，默认列索引为0、1、2……；当data为dict类型时，默认列索引为dict的键）
可以使用list自定义列索引，注意：
① columns长度必须与data的列数相等，否则报错；
② 当data为dict类型时，不可以在pd.DataFrame()括号里自定义columns，否则会清空整个DataFrame（见下面的错误演示）。由于dict的键已经作为columns了，因此不能再自定义columns。
③ 默认的columns（0、1、2……）称为position（位置），自定义的columns称为label（标签）。未定义columns时，只能通过position取值；定义columns后，既可以通过position取值，也可以通过label取值。
dtype：数据类型，值为'f'时表示float，值为'i'时表示int
注意：和Series不同，DataFrame没有name参数！
# 通过list和numpy.ndarray创建DataFrame
import numpy as np
import pandas as pd
li = [[44, 55, 66],[77, 88, 99]]
df1 = pd.DataFrame(li,columns=['c1','c2','c3'],index=['t1','t2'])
arr = np.array([[44, 55, 66],[77, 88, 99]])
df2 = pd.DataFrame(arr,columns=['c1','c2','c3'],index = ['t1','t2'])
print(df1); print('===========')
print(df2); print('==========='); print(type(df2))
执行结果：
c1 c2 c3
t1 44 55 66
t2 77 88 99
===========
c1 c2 c3
t1 44 55 66
t2 77 88 99
===========
<class 'pandas.core.frame.DataFrame'>
# 通过dict创建DataFrame
import numpy as np
import pandas as pd
dic1 = {
'A': [30,32],
'B': np.array([42,38]),
'C': pd.Series([55,56]),
}
dic2 = {
'A': pd.Series([30,32], index=['t1','t2']),
'B': pd.Series([42,38], index=['t1','t2']),
'C': pd.Series([55,56], index=['t1','t2']),
}
# 正确的创建方式一
df1 = pd.DataFrame(dic1)
df1.index=['t1','t2']
# 正确的创建方式二
df2 = pd.DataFrame(dic2)
# 错误的创建方式三
df3 = pd.DataFrame(dic1,index=['t1','t2'])
# 错误的创建方式四
df4 = pd.DataFrame(dic1,columns=['c1','c2'])
print('正确的创建方式一\n',df1); print('===========')
print('正确的创建方式二\n',df2); print('===========')
print('错误的创建方式三\n',df3); print('===========')
print('错误的创建方式四\n',df4)
执行结果：
正确的创建方式一
A B C
t1 30 42 55
t2 32 38 56
===========
正确的创建方式二
A B C
t1 30 42 55
t2 32 38 56
===========
错误的创建方式三
A B C
t1 30 42 NaN
t2 32 38 NaN
===========
错误的创建方式四
Empty DataFrame
Columns: [c1, c2]
Index: []
5. DataFrame对象的属性
（1）df.columns
返回df的列索引：
- 如果未自定义过df.columns，则返回的数据类型为pandas.core.indexes.range.RangeIndex
- 如果已自定义过df.columns，则返回的数据类型为pandas.core.indexes.base.Index
df.columns支持索引和切片：
- 当对df.columns里面的单一元素进行索引时（即df.columns[]的中括号里无冒号）：
- 若此时未自定义过df.columns，则返回int类型的位置索引
- 若此时已自定义过df.columns，则返回str类型（或其他类型）的标签索引
- 当对df.columns切片时（即df.columns[]的中括号里有冒号，不论切片的长度是多少，哪怕切片里只有一项）：
- 若此时未自定义过df.columns，则返回pandas.core.indexes.range.RangeIndex类型的位置索引
- 若此时已自定义过df.columns，则返回pandas.core.indexes.base.Index类型的标签索引
df.columns支持对其整体进行重新赋值，但不支持对其中的元素进行修改（会报错）
import numpy as np
import pandas as pd
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
df = pd.DataFrame(arr,index=['t1','t2','t3','t4']) # 定义df时未定义columns
print('df\n',df); print('===========')
print('df.columns\n',df.columns,'\n',type(df.columns)); print('===========')
print('df.columns[2]\n',df.columns[2],'\n',type(df.columns[2])); print('===========')
print('df.columns[2:3]\n',df.columns[2:3],'\n',type(df.columns[2:3])); print('===========')
# 可以对df.columns整体进行重新赋值
df.columns=['c1','c2','c3','c4']
print('df\n',df,'\n',type(df)); print('===========')
print('df.columns\n',df.columns,'\n',type(df.columns)); print('===========')
print('df.columns[2]\n',df.columns[2],'\n',type(df.columns[2])); print('===========')
print('df.columns[2:3]\n',df.columns[2:3],'\n',type(df.columns[2:3])); print('===========')
# 不可以对df.columns中的元素进行修改（会报错）
df.columns[1]='New'
print(df)
执行结果：
df
0 1 2 3
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
t4 13 14 15 16
===========
df.columns
RangeIndex(start=0, stop=4, step=1)
<class 'pandas.core.indexes.range.RangeIndex'>
===========
df.columns[2]
2
<class 'int'>
===========
df.columns[2:3]
RangeIndex(start=2, stop=3, step=1)
<class 'pandas.core.indexes.range.RangeIndex'>
===========
df
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
t4 13 14 15 16
<class 'pandas.core.frame.DataFrame'>
===========
df.columns
Index(['c1', 'c2', 'c3', 'c4'], dtype='object')
<class 'pandas.core.indexes.base.Index'>
===========
df.columns[2]
c3
<class 'str'>
===========
df.columns[2:3]
Index(['c3'], dtype='object')
<class 'pandas.core.indexes.base.Index'>
===========
报错（TypeError: Index does not support mutable operations）
（2）df.index
返回df的行索引：
- 如果未自定义过df.index，则返回的数据类型为pandas.core.indexes.range.RangeIndex
- 如果已自定义过df.index，则返回的数据类型为pandas.core.indexes.base.Index
df.index支持索引和切片：
- 当对df.index里面的单一元素进行索引时（即df.index[]的中括号里无冒号）：
- 若此时未自定义过df.index，则返回int类型的位置索引
- 若此时已自定义过df.index，则返回str类型（或其他类型）的标签索引
- 当对df.index切片时（即df.index[]的中括号里有冒号，不论切片的长度是多少，哪怕切片里只有一项）：
- 若此时未自定义过df.index，则返回pandas.core.indexes.range.RangeIndex类型的位置索引
- 若此时已自定义过df.index，则返回pandas.core.indexes.base.Index类型的标签索引
df.index支持对其整体进行重新赋值，但不支持对其中的元素进行修改（会报错）
import numpy as np
import pandas as pd
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
df = pd.DataFrame(arr,columns=['c1','c2','c3','c4']) # 定义df时未定义index
print('df\n',df); print('===========')
print('df.index\n',df.index,'\n',type(df.index)); print('===========')
print('df.index[2]\n',df.index[2],'\n',type(df.index[2])); print('===========')
print('df.index[2:3]\n',df.index[2:3],'\n',type(df.index[2:3])); print('===========')
# 可以对df.index整体进行重新赋值
df.index=['t1','t2','t3','t4']
print('df\n',df,'\n',type(df)); print('===========')
print('df.index\n',df.index,'\n',type(df.index)); print('===========')
print('df.index[2]\n',df.index[2],'\n',type(df.index[2])); print('===========')
print('df.index[2:3]\n',df.index[2:3],'\n',type(df.index[2:3])); print('===========')
# 不可以对df.index中的元素进行修改（会报错）
df.index[2]='New'
print(df)
执行结果：
df
c1 c2 c3 c4
0 1 2 3 4
1 5 6 7 8
2 9 10 11 12
3 13 14 15 16
===========
df.index
RangeIndex(start=0, stop=4, step=1)
<class 'pandas.core.indexes.range.RangeIndex'>
===========
df.index[2]
2
<class 'int'>
===========
df.index[2:3]
RangeIndex(start=2, stop=3, step=1)
<class 'pandas.core.indexes.range.RangeIndex'>
===========
df
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
t4 13 14 15 16
<class 'pandas.core.frame.DataFrame'>
===========
df.index
Index(['t1', 't2', 't3', 't4'], dtype='object')
<class 'pandas.core.indexes.base.Index'>
===========
df.index[2]
t3
<class 'str'>
===========
df.index[2:3]
Index(['t3'], dtype='object')
<class 'pandas.core.indexes.base.Index'>
===========
报错（TypeError: Index does not support mutable operations）
（3）df.index.name和df.index.names
对于单一索引的df来说，df.index.name和df.index.names是同一个东西，对其中一个赋值会覆盖另一个的值，示例代码见例1、例2
对于层次化索引的df来说，df.index.name是一个标量（整个层次化索引的名字），而df.index.names是一个矢量（每一列层次化索引的单独的列名），示例代码见例3
# 例1：单一索引的df.index.names覆盖df.index.name
import numpy as np
import pandas as pd
df = pd.DataFrame([1,2,3])
df.columns = ['c1']
df.index = ['t1','t2','t3']
df.index.name = 'my_index'
df.index.names = ['t'] # 将前面的df.index.name覆盖掉了
print(df); print('===========')
print(df.index); print('===========')
print(df.index.name); print('===========')
print(df.index.names)
执行结果：
c1
t
t1 1
t2 2
t3 3
===========
Index(['t1', 't2', 't3'], dtype='object', name='t')
===========
t
===========
['t']
# 例2：单一索引的df.index.name覆盖df.index.names
import numpy as np
import pandas as pd
df = pd.DataFrame([1,2,3])
df.columns = ['c1']
df.index = ['t1','t2','t3']
df.index.names = ['t']
df.index.name = 'my_index' # 将前面的df.index.names覆盖掉了
print(df); print('===========')
print(df.index); print('===========')
print(df.index.name); print('===========')
print(df.index.names)
执行结果：
c1
my_index
t1 1
t2 2
t3 3
===========
Index(['t1', 't2', 't3'], dtype='object', name='my_index')
===========
my_index
===========
['my_index']
# 例3：层次化索引的df.index.name和df.index.names是互相互独立的
import numpy as np
import pandas as pd
df = pd.DataFrame([1,2,3,4,5,6,7,8])
df.columns = ['c1']
df.index = [['A','A','B','B','C','C','D','D'],
['e','f','e','g','f','h','g','h']]
df.index.name = 'my_multi_index'
df.index.names = ['i1','i2']
print(df); print('===========')
print(df.index); print('===========')
print(df.index.name); print('===========')
print(df.index.names)
执行结果：
c1
i1 i2
A e 1
f 2
B e 3
g 4
C f 5
h 6
D g 7
h 8
===========
MultiIndex([('A', 'e'),
('A', 'f'),
('B', 'e'),
('B', 'g'),
('C', 'f'),
('C', 'h'),
('D', 'g'),
('D', 'h')],
name='my_multi_index')
===========
my_multi_index
===========
['i1', 'i2']
（4）df.index.levels
以list形式返回df的各级层次化索引
注意：未设定行索引时df.index是pandas.core.indexes.range.RangeIndex的实例化对象，设定单一层次化索引时df.index是pandas.core.indexes.base.Index的实例化对象，这两种情况下执行df.index.levels都会报错，因为它们没有这个属性。仅两层或更多层的索引（pandas.core.indexes.multi.MultiIndex的实例化对象）才有levels属性。
# 一层index
import numpy as np
import pandas as pd
df = pd.DataFrame([1,2,3])
df.columns = ['c1']
df.index = ['t1','t2','t3']
print(type(df.index))
print(df.index.levels)
执行结果：
<class 'pandas.core.indexes.base.Index'>
报错
# 两层index
import numpy as np
import pandas as pd
df = pd.DataFrame([1,2,3])
df.columns = ['c1']
df.index = [['A','B','C'],['t1','t2','t3']]
print(type(df.index))
print(df.index.levels)
执行结果：
<class 'pandas.core.indexes.multi.MultiIndex'>
[['A', 'B', 'C'], ['t1', 't2', 't3']]
# 三层index
import numpy as np
import pandas as pd
df = pd.DataFrame([1,2,3])
df.columns = ['c1']
df.index = [[10,20,30],['A','B','C'],['t1','t2','t3']]
print(type(df.index))
print(df.index.levels)
执行结果：
<class 'pandas.core.indexes.multi.MultiIndex'>
[[10, 20, 30], ['A', 'B', 'C'], ['t1', 't2', 't3']]
（5）df.dtypes
返回每列的数据类型，即返回df中每列Series的dtype
返回值整体是一个Series
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,'a',3+4j],[2,'b',5+6j]],columns=['c1','c2','c3'],index=['t1','t2'])
print(df.dtypes)
print('==============')
print(type(df.dtypes))
执行结果：
c1 int64
c2 object
c3 complex128
dtype: object
==============
<class 'pandas.core.series.Series'>
（6）df.shape
返回一个元组，元组中的两项分别是df的行数和列数
import numpy as np
import pandas as pd
df1 = pd.DataFrame()
df2 = pd.DataFrame([10,11]) # pd.DataFrame()将一维列表变为了列向量
df3 = pd.DataFrame(np.array([10,11])) # pd.DataFrame()将一维numpy.ndarray变为了列向量
df4 = pd.DataFrame([[10,11]])
df5 = pd.DataFrame([[10],[11]])
df6 = pd.DataFrame([[10,11],[12,13]])
print(df1.shape,type(df1.shape))
print(df2.shape,type(df2.shape))
print(df3.shape,type(df3.shape))
print(df4.shape,type(df4.shape))
print(df5.shape,type(df5.shape))
print(df6.shape,type(df6.shape))
执行结果：
(0, 0) <class 'tuple'>
(2, 1) <class 'tuple'>
(2, 1) <class 'tuple'>
(1, 2) <class 'tuple'>
(2, 1) <class 'tuple'>
(2, 2) <class 'tuple'>
（7）df.values
获取df的所有值，不含行索引、列索引，返回numpy.ndarray类型。示例代码见“6.DataFrame的数据选择 - （5）使用df的属性和方法进行数据选择”
（8）df.列标签
获取df的某一列，返回Series类型，注意df.列标签是不加引号的。示例代码见“6.DataFrame的数据选择 - （5）使用df的属性和方法进行数据选择”
（9）df.empty
判断df是否为空，返回bool。当df=pd.DataFrame()时，df为空，返回True；只要df中有数据，哪怕这些数据本身都为空，df也不为空（返回False）。
6. DataFrame的数据选择
（1）使用df[]进行选择
df[]支持的操作有：
- 使用
df['列标签']获取某一列（Series类型） - 使用
df[['列标签','列标签']]获取不连续的一列或多列（花式索引）（DataFrame类型） - 使用
df['行标签':'行标签']、df[:'行标签']、df['行标签':]获取连续的一行或多行（DataFrame类型） - 使用
df[行索引号:行索引号]、df[:行索引号]、df[行索引号:]获取连续的一行或多行（DataFrame类型） - 当df行索引为pandas.core.indexes.datetimes.DatetimeIndex或pandas.core.indexes.period.PeriodIndex类型时，还可以使用
df['年-月']、df['年.月']、df['年']等模糊索引方式获取满足条件的若干行（DataFrame类型），详见本章“14. Pandas中的时间相关格式及方法-（1）Pandas中的时间格式及特殊索引、切片方法”
df[]不支持的操作包括但不限于：
- 对连续的列进行切片
- 对不连续的行进行切片
# 例1：前四种索引方式
import numpy as np
import pandas as pd
arr=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
df = pd.DataFrame(arr,columns=['c1','c2','c3','c4'],index=['t1','t2','t3','t4'])
print("查看df\n",df); print('===========')
# 使用 df['列标签'] 获取某一列（Series类型）
print("获取'c3'列\n",df['c3'],'\n',type(df['c3'])); print('===========')
# 使用 df[['列标签','列标签']] 获取不连续的若干列（花式索引）（DataFrame类型）
print("获取'c3','c1'列\n",df[['c3','c1']],'\n',type(df[['c3','c1']])); print('===========')
# 使用 df['行标签':'行标签']、df[:'行标签']、df['行标签':] 获取连续的一行或多行（DataFrame类型）
print("获取't3'行\n",df['t3':'t3'],'\n',type(df['t3':'t3'])); print('===========')
print("获取第一行到't3'行\n",df[:'t3'],'\n',type(df['t3':'t3'])); print('===========')
# 使用 df[行索引号:行索引号]、df[:行索引号]、df[行索引号:] 获取连续的一行或多行（DataFrame类型）
print("获取第三行\n",df[2:3],'\n',type(df[2:3])); print('===========')
print("获取第一行到第三行\n",df[:3],'\n',type(df[:3]))
执行结果：
查看df
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
t4 13 14 15 16
===========
获取'c3'列
t1 3
t2 7
t3 11
t4 15
Name: c3, dtype: int32
<class 'pandas.core.series.Series'>
===========
获取'c3','c1'列
c3 c1
t1 3 1
t2 7 5
t3 11 9
t4 15 13
<class 'pandas.core.frame.DataFrame'>
===========
获取't3'行
c1 c2 c3 c4
t3 9 10 11 12
<class 'pandas.core.frame.DataFrame'>
===========
获取第一行到't3'行
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
<class 'pandas.core.frame.DataFrame'>
===========
获取第三行
c1 c2 c3 c4
t3 9 10 11 12
<class 'pandas.core.frame.DataFrame'>
===========
获取第一行到第三行
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
<class 'pandas.core.frame.DataFrame'>
（2）使用基于标签索引的df.loc[]
loc是location的简写
df.loc[]支持的索引类型如下：
| df有列标签索引 | df无列标签索引 | |
|---|---|---|
| df有行标签索引 | 支持行标签索引、列标签索引 不支持行位置索引、列位置索引 |
支持行标签索引、列位置索引 不支持行位置索引、列标签索引 |
| df无行标签索引 | 支持行位置索引、列标签索引 不支持行标签索引、列位置索引 |
支持行位置索引、列位置索引 不支持行标签索引、列标签索引 |
总结一句话：有标签索引时只能用标签索引，没有标签索引时才能用位置索引
注意标签索引使用冒号:切片时是前后都包含的，而位置索引使用冒号:切片时是顾前不顾后的，此外还要注意位置索引是从0开始的
可以通过df.loc[]选取任意行、任意列。若选取的行数、列数都为1，则返回该位置元素本身的数据类型；若行数、列数只有一个为1，则返回Series类型；若行数、列数都不为1，则返回DataFrame类型
关于pd.date_range()的标签索引方式，详见本章“10.DataFrame对象的方法和Pandas模块的方法 - （4）时间相关方法 - ①pd.date_range()”
import numpy as np
import pandas as pd
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
df = pd.DataFrame(arr,columns=['c1','c2','c3','c4'],index=['t1','t2','t3','t4'])
print("查看df\n",df); print('===========')
# 使用 df.loc['行标签'] 获取某一行（Series类型）
print("获取't1'行\n",df.loc['t2'],'\n',type(df.loc['t2'])); print('===========')
# 使用 df.loc['行标签':'行标签'] 获取连续的若干行（前后都包含）（DataFrame类型）
print("获取't2'至't3'行（前后都包含）\n",df.loc['t2':'t3'],'\n',type(df.loc['t2':'t3'])); print('===========')
# 使用 df.loc[['行标签','行标签']] 获取不连续的若干行（花式索引）（DataFrame类型）
print("获取't3'和't1'行\n",df.loc[['t3','t1']],'\n',type(df.loc[['t3','t1']])); print('===========')
# 使用 df.loc[:,'列标签'] 获取某一列（Series类型）
print("获取'c2'列\n",df.loc[:,'c2'],'\n',type(df.loc[:,'c2'])); print('===========')
# 使用 df.loc[:,'列标签':'列标签'] 获取连续的若干列（前后都包含）（DataFrame类型）
print("获取'c2'至'c3'列（前后都包含）\n",df.loc[:,'c2':'c3'],'\n',type(df.loc[:,'c2':'c3'])); print('===========')
# 使用 df.loc[:,['行标签','行标签']] 获取不连续的若干列（花式索引）（DataFrame类型）
print("获取'c3'和'c1'列\n",df.loc[:,['c3','c1']],'\n',type(df.loc[:,['c3','c1']])); print('===========')
# 使用 df.loc['行标签','列标签'] 获取某一个元素（该位置元素本身的数据类型）
print("获取't4'行,'c4'列位置的元素\n",df.loc['t4','c4'],'\n',type(df.loc['t4','c4'])); print('===========')
# 使用上述方法的各种组合获取某几行、某几列（若选取的行数、列数都为1，则返回该位置元素本身的数据类型；若行数、列数只有一个为1，则返回Series类型；若行数、列数都不为1，则返回DataFrame类型）
print("获取't2'至't3'行,'c2'至'c3'列\n",df.loc['t2':'t3','c2':'c3'],'\n',type(df.loc['t2':'t3','c2':'c3'])); print('===========')
print("获取't4'行,'c4'和'c1'列\n",df.loc['t4',['c4','c1']],'\n',type(df.loc['t4',['c4','c1']]))
执行结果：
查看df
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
t4 13 14 15 16
===========
获取't1'行
c1 5
c2 6
c3 7
c4 8
Name: t2, dtype: int32
<class 'pandas.core.series.Series'>
===========
获取't2'至't3'行（前后都包含）
c1 c2 c3 c4
t2 5 6 7 8
t3 9 10 11 12
<class 'pandas.core.frame.DataFrame'>
===========
获取't3'和't1'行
c1 c2 c3 c4
t3 9 10 11 12
t1 1 2 3 4
<class 'pandas.core.frame.DataFrame'>
===========
获取'c2'列
t1 2
t2 6
t3 10
t4 14
Name: c2, dtype: int32
<class 'pandas.core.series.Series'>
===========
获取'c2'至'c3'列（前后都包含）
c2 c3
t1 2 3
t2 6 7
t3 10 11
t4 14 15
<class 'pandas.core.frame.DataFrame'>
===========
获取'c3'和'c1'列
c3 c1
t1 3 1
t2 7 5
t3 11 9
t4 15 13
<class 'pandas.core.frame.DataFrame'>
===========
获取't4'行,'c4'列位置的元素
16
<class 'numpy.int32'>
===========
获取't2'至't3'行,'c2'至'c3'列
c2 c3
t2 6 7
t3 10 11
<class 'pandas.core.frame.DataFrame'>
===========
获取't4'行,'c4'和'c1'列
c4 16
c1 13
Name: t4, dtype: int32
<class 'pandas.core.series.Series'>
（3）使用基于位置索引的df.iloc[]
iloc是index location的简写
即使DataFrame已自定义了columns和index，仍然可以使用位置索引通过df.iloc[]进行选择
和df.loc[]不同，不论df有没有行标签、列标签，df.iloc[]都只支持位置索引（position index），位置索引使用冒号:切片时是顾前不顾后的，此外还要注意位置索引是从0开始的
可以通过df.iloc[]选取任意行、任意列。若选取的行数、列数都为1，则返回该位置元素本身的数据类型；若行数、列数只有一个为1，则返回Series类型；若行数、列数都不为1，则返回DataFrame类型
特别地，使用df.iloc[]可以实现倒序排列：
-
df.iloc[::-1,:]：倒序排所有行 -
df.iloc[:,::-1]：倒序排所有列 -
df.iloc[::-1,::-1]：倒序排所有行、所有列
import numpy as np
import pandas as pd
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
df = pd.DataFrame(arr,columns=['c1','c2','c3','c4'],index=['t1','t2','t3','t4'])
print("查看df\n",df); print('===========')
# 使用 df.iloc[行索引] 获取某一行（Series类型）
print("获取最后一行\n",df.iloc[-1],'\n',type(df.iloc[-1])); print('===========')
# 使用 df.iloc[行索引:行索引] 获取连续的若干行（顾前不顾后）（DataFrame类型）
print("获取第二行至倒数第二行\n",df.iloc[1:-1],'\n',type(df.iloc[1:-1])); print('===========')
# 使用 df.iloc[[行索引,行索引]] 获取不连续的若干行（花式索引）（DataFrame类型）
print("获取倒数第二行和第一行\n",df.iloc[[-2,0]],'\n',type(df.iloc[[-2,0]])); print('===========')
# 使用 df.iloc[:,列索引] 获取某一列（Series类型）
print("获取最后一列\n",df.iloc[:,-1],'\n',type(df.iloc[:,-1])); print('===========')
# 使用 df.iloc[:,列索引:列索引] 获取连续的若干列（顾前不顾后）（DataFrame类型）
print("获取第二列至倒数第二列\n",df.iloc[:,1:-1],'\n',type(df.iloc[:,1:-1])); print('===========')
# 使用 df.iloc[:,[列索引,列索引]] 获取不连续的若干列（花式索引）（DataFrame类型）
print("获取倒数第二列和第一列\n",df.iloc[:,[-2,0]],'\n',type(df.iloc[:,[-2,0]])); print('===========')
# 使用 df.iloc[行索引,列索引] 获取某一个元素（该位置元素本身的数据类型）
print("获取最后一行,最后一列的元素\n",df.iloc[-1,-1],'\n',type(df.iloc[-1,-1])); print('===========')
# 使用上述方法的各种组合获取某几行、某几列（若选取的行数、列数都为1，则返回该位置元素本身的数据类型；若行数、列数只有一个为1，则返回Series类型；若行数、列数都不为1，则返回DataFrame类型）
print("获取第一行至倒数第二行,第三列至最后一列\n",df.iloc[:-1,2:],'\n',type(df.iloc[:-1,2:])); print('===========')
print("获取第四行,最后一列和倒数第三列\n",df.iloc[3,[-1,-3]],'\n',type(df.iloc[3,[-1,-3]])); print('===========')
# 使用df.iloc[]实现倒序排
print("倒序排所有行\n",df.iloc[::-1,:]); print('===========')
print("倒序排所有列\n",df.iloc[:,::-1]); print('===========')
print("倒序排所有行和所有列\n",df.iloc[::-1,::-1])
执行结果：
查看df
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
t4 13 14 15 16
===========
获取最后一行
c1 13
c2 14
c3 15
c4 16
Name: t4, dtype: int32
<class 'pandas.core.series.Series'>
===========
获取第二行至倒数第二行
c1 c2 c3 c4
t2 5 6 7 8
t3 9 10 11 12
<class 'pandas.core.frame.DataFrame'>
===========
获取倒数第二行和第一行
c1 c2 c3 c4
t3 9 10 11 12
t1 1 2 3 4
<class 'pandas.core.frame.DataFrame'>
===========
获取最后一列
t1 4
t2 8
t3 12
t4 16
Name: c4, dtype: int32
<class 'pandas.core.series.Series'>
===========
获取第二列至倒数第二列
c2 c3
t1 2 3
t2 6 7
t3 10 11
t4 14 15
<class 'pandas.core.frame.DataFrame'>
===========
获取倒数第二列和第一列
c3 c1
t1 3 1
t2 7 5
t3 11 9
t4 15 13
<class 'pandas.core.frame.DataFrame'>
===========
获取最后一行,最后一列的元素
16
<class 'numpy.int32'>
===========
获取第一行至倒数第二行,第三列至最后一列
c3 c4
t1 3 4
t2 7 8
t3 11 12
<class 'pandas.core.frame.DataFrame'>
===========
获取第四行,最后一列和倒数第三列
c4 16
c2 14
Name: t4, dtype: int32
<class 'pandas.core.series.Series'>
===========
倒序排所有行
c1 c2 c3 c4
t4 13 14 15 16
t3 9 10 11 12
t2 5 6 7 8
t1 1 2 3 4
===========
倒序排所有列
c4 c3 c2 c1
t1 4 3 2 1
t2 8 7 6 5
t3 12 11 10 9
t4 16 15 14 13
===========
倒序排所有行和所有列
c4 c3 c2 c1
t4 16 15 14 13
t3 12 11 10 9
t2 8 7 6 5
t1 4 3 2 1
（4）使用基于混合索引的df.ix[]（新版Pandas即将取消该功能）
df.ix[]既支持位置索引（position index），也支持标签索引（label index），位置索引使用冒号:切片时是顾前不顾后的，标签索引使用冒号:切片时是前后都包含的
可以通过df.ix[]选取任意行、任意列。若选取的行数、列数都为1，则返回该位置元素本身的数据类型；若行数、列数只有一个为1，则返回Series类型；若行数、列数都不为1，则返回DataFrame类型
关于pd.date_range()的标签索引方式，详见本章“10.DataFrame对象的方法和Pandas模块的方法 - （4）时间相关方法 - ①pd.date_range()”
注意事项：
- 当
df.ix[]的中括号里没有逗号时，自动视为行索引或行标签 - 在
df.ix[,]中，可以对行使用一种索引方法，对列使用另一种索引方法 - 不可以在冒号
:两边分别使用位置索引和标签索引 - 不可以在花式索引列表
[]中同时出现位置索引和标签索引 - 使用df.ix[]会有warning警告，因为新版Pandas即将取消该功能
import numpy as np
import pandas as pd
import warnings; warnings.simplefilter('ignore') # 忽略可能会出现的警告信息；警告并不是错误，可以忽略；可能出现警告的场景包括：df.ix[]、pd.concat()
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
df = pd.DataFrame(arr,columns=['c1','c2','c3','c4'],index=['t1','t2','t3','t4'])
print("查看df\n",df); print('===========')
# 正确的示例
print("获取最后一行\n",df.ix[-1]); print('===========')
print("获取第一行至't3'行\n",df.ix[:'t3']); print('===========')
print("获取第一行至倒数第三行,'c4'列和'c3'列\n",df.ix[:-2, ['c4','c3']])
# 错误的示例
# print("不可以在冒号:两边分别使用位置索引和标签索引，会报错\n",df.ix[1:'t1', 2])
# print("不可以在花式索引列表[]中同时出现位置索引和标签索引，会报错\n",df.ix[1:, [1,'c3']])
执行结果：
查看df
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
t4 13 14 15 16
===========
获取最后一行
c1 13
c2 14
c3 15
c4 16
Name: t4, dtype: int32
===========
获取第一行至't3'行
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
===========
获取第一行至倒数第三行,'c4'列和'c3'列
c4 c3
t1 4 3
t2 8 7
（5）使用df的属性和方法进行选择
具体包括下面几种属性和方法：
- df.列标签：获取某一列，返回Series类型，注意
df.列标签是不加引号的 - df.values：获取所有值，不含行索引、列索引，返回numpy.ndarray类型
- df.head(n=5)：获取前n行，n的默认值为5，返回DataFrame类型
- df.tail(n=5)：获取后n行，n的默认值为5，返回DataFrame类型
import numpy as np
import pandas as pd
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
df = pd.DataFrame(arr,columns=['c1','c2','c3','c4'],index=['t1','t2','t3','t4'])
print("查看df\n",df); print('===========')
# 使用 df.列标签 获取某一列（Series类型）
print("获取'c3'列\n",df.c3,'\n',type(df.c3)); print('===========')
# 无法使用 df.列索引号 获取某一列
# 无法使用 df.行标签 获取某一行
# 无法使用 df.行索引号 获取某一行
# 使用 df.values 获取所有值，不含行索引、列索引（numpy.ndarray类型）
print("获取df所有值\n",df.values,'\n',type(df.values))
# 使用 df.head(n) 获取前n行（DataFrame类型）
print("获取前2行\n",df.head(2),'\n',type(df.head(2))); print('===========')
# 使用 df.tail(n) 获取后n行（DataFrame类型）
print("获取后2行\n",df.tail(2),'\n',type(df.tail(2)))
执行结果：
查看df
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
t3 9 10 11 12
t4 13 14 15 16
===========
获取'c3'列
t1 3
t2 7
t3 11
t4 15
Name: c3, dtype: int32
<class 'pandas.core.series.Series'>
===========
获取df所有值
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]
[13 14 15 16]]
<class 'numpy.ndarray'>
获取前2行
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
<class 'pandas.core.frame.DataFrame'>
===========
获取后2行
c1 c2 c3 c4
t3 9 10 11 12
t4 13 14 15 16
<class 'pandas.core.frame.DataFrame'>
（6）使用布尔值索引筛选满足条件的行
如果需要根据某列的值是否满足给定的条件，筛选出满足条件的整行数据（或这些行指定字段的数据），可以使用下面的方法：
# 用于筛选满足条件的行
df[由布尔值组成的list]
df[由“df.列标签”组成的条件]
df[由“df['列标签']”组成的条件]
df.loc[由“df.列标签”组成的条件, :]
df.loc[由“df['列标签']”组成的条件, :]
# 用于筛选满足条件的行、列
df.loc[由“df.列标签”组成的条件, 由“df.列标签”组成的条件]
df.loc[由“df['列标签']”组成的条件, 由“df['列标签']”组成的条件]
条件之间的逻辑运算符有|、&、~、np.logical_or()、np.logical_and()、np.logical_not()，每个运算符的详细介绍见“第五章 Python编程进阶 - 一、NumPy模块 - 8. ndarray对象的方法和NumPy模块的方法 - （2）二元通用函数 - ③ 基本逻辑运算”
可以根据布尔值的特性（True=1，False=0），把条件*1并用+连接，以便对满足条件的数量进行筛选
import numpy as np
import pandas as pd
df = pd.DataFrame([[10,8,6],[8,15,13],[13,7,14],[9,9,11]],columns=['c1','c2','c3'],index=['t1','t2','t3','t4'])
print(df); print('===========')
print(df.c1>9); print('===========') # 写成df['c1']>9也行
print(df[df.c1>9]); print('===========') # 写成df[df['c1']>9]也行
print(df[(df.c1>9) & (df.c3>9)]); print('===========') # 筛选两个条件都满足的（且）
print(df[(df.c1>9) | (df.c3>9)]); print('===========') # 筛选满足任意一个条件的（或）
print(df[(df.c1>9)*1 + (df.c2>9)*1 + (df.c3>9)*1 >=2 ]) # 筛选三个条件中至少满足两个的（布尔值特性）
print('===========')
print(df.loc[df.c1.isin([8,9,22,33]),['c2','c3']]) # 筛选'c1'列的值在给定列表里的行的'c2'和'c3'列
执行结果：
c1 c2 c3
t1 10 8 6
t2 8 15 13
t3 13 7 14
t4 9 9 11
===========
t1 True
t2 False
t3 True
t4 False
Name: c1, dtype: bool
===========
c1 c2 c3
t1 10 8 6
t3 13 7 14
===========
c1 c2 c3
t3 13 7 14
===========
c1 c2 c3
t1 10 8 6
t2 8 15 13
t3 13 7 14
t4 9 9 11
===========
c1 c2 c3
t2 8 15 13
t3 13 7 14
===========
c2 c3
t2 15 13
t4 9 11
（7）使用df.query()筛选满足条件的行
语法：df.query('列标签组成的str格式表达式',inplace=False)
通过列标签组成的str格式表达式筛选满足条件的行，返回DataFrame格式的筛选结果，注意：
当表达式中含有变量时，需要在变量名称前加@符号
当表达式中含有带空格的列标签时，需要在此列标签的两侧加`符号
import numpy as np
import pandas as pd
df = pd.DataFrame([[10,8,6],[8,15,13],[13,7,14],[9,9,11]],
columns=['c1','c2','c 3'],
index=['t1','t2','t3','t4'])
var = 9
print(df); print('===========')
print(df.query('c1 > 9')); print('===========')
print(df.query('c1 > @var')); print('===========')
# print(df.query('c1 > c 3')); print('===========') # 报错
print(df.query('c1 > `c 3`'))
执行结果：
c1 c2 c 3
t1 10 8 6
t2 8 15 13
t3 13 7 14
t4 9 9 11
===========
c1 c2 c 3
t1 10 8 6
t3 13 7 14
===========
c1 c2 c 3
t1 10 8 6
t3 13 7 14
===========
c1 c2 c 3
t1 10 8 6
（8）循环遍历df每一行数据
可以使用df.iterrows()返回的生成器实现，见本章“10. DataFrame对象的方法和Pandas模块的方法 - （5）其他重要方法 - ② df.iterrows()”
7. DataFrame的向量化、对齐和广播
（1）向量化和对齐
DataFrame的向量化是一种比numpy.ndarray和Series更为广义的向量化：
- 算数运算（+、-、*、/、**、//、%）
- 当两个DataFrame的shape、行标签、列标签都完全相同时，它们的算数运算就是对应项的运算，结果也是一个shape相同的DataFrame
- 当两个DataFrame的shape、行标签、列标签不完全相同时，它们之间也可以进行算数运算，此时行标签、列标签都相同的项才会执行元素级别的计算，不同的项则返回NaN。最终得到的DataFrame的shape会大于两个参与运算的DataFrame，因为前者的行标签是后两者行标签的并集，前者的列标签也是后两者列标签的并集。上述规则称为DataFrame的对齐。
- DataFrame可以和一个shape相同的二维numpy.ndarray进行算数运算，返回一个shape、行标签、列标签都相同的DataFrame
- DataFrame不能和一个shape不同的二维numpy.ndarray进行算数运算，也不能和任何二维list进行算数运算（哪怕二者shape相同）（报错）
- 比较运算（><、>=、<=、==、!=）
- 当两个DataFrame的shape、行标签、列标签都完全相同时，它们之间可以执行比较运算，返回一个shape相同的DataFrame，值为True或False
- 当两个DataFrame的shape、行标签、列标签不完全相同时，它们之间不能执行比较运算（报错），即此时DataFrame无法对齐
- DataFrame可以和一个shape相同的二维numpy.ndarray进行比较运算，返回一个shape、行标签、列标签都相同的DataFrame，值为True或False
- DataFrame不能和一个shape不同的二维numpy.ndarray进行比较运算，也不能和任何二维list进行比较运算（哪怕二者shape相同）（报错）
关于对齐的总结：如果两个DataFrame的shape、行标签、列标签不完全相同，进行算数运算时可以实现对齐，进行比较运算时无法实现对齐（只能报错）
关于对齐产生的NaN的后续处理：详见本章 “ 7.DataFrame的修改 - 对NaN进行替换 “
上面两类运算均未提到DataFrame和Series之间的计算，因为DataFrame必然是二维的，Series必然是一维的，因此它们二者之间只能是广播的关系，不属于向量化的范畴，其规则详见本章“广播”部分
# DataFrame的对齐
import numpy as np
import pandas as pd
df1 = pd.DataFrame([[10,20,30,40],[50,60,70,80]],columns=['c1','c2','c3','c4'],index=['t1','t2'])
df2 = pd.DataFrame([[1,2,3],[4,5,6],[7,8,9]],columns=['c0','c3','c1'],index=['t0','t2','t1'])
print('df1\n',df1); print('===========')
print('df2\n',df2); print('===========')
print('df1 + df2\n',df1 + df2); print('===========')
print('df1 // df2\n',df1 // df2); print('===========')
print('df1 > df2\n',df1 > df2)
执行结果：
df1
c1 c2 c3 c4
t1 10 20 30 40
t2 50 60 70 80
===========
df2
c0 c3 c1
t0 1 2 3
t2 4 5 6
t1 7 8 9
===========
df1 + df2
c0 c1 c2 c3 c4
t0 NaN NaN NaN NaN NaN
t1 NaN 19.0 NaN 38.0 NaN
t2 NaN 56.0 NaN 75.0 NaN
===========
df1 // df2
c0 c1 c2 c3 c4
t0 NaN NaN NaN NaN NaN
t1 NaN 1.0 NaN 3.0 NaN
t2 NaN 8.0 NaN 14.0 NaN
===========
报错（ValueError: Can only compare identically-labeled DataFrame objects）
# 仅当两个DataFrame的shape、行标签、列标签都完全相同时，它们之间才能执行><、>=、<=、==、!=的比较运算
import numpy as np
import pandas as pd
df1 = pd.DataFrame([[3,4],[5,6]],columns=['c1','c2'],index=['t1','t2'])
df2 = pd.DataFrame([[1,2],[7,8]],columns=['c1','c2'],index=['t1','t2'])
print('df1\n',df1); print('===========')
print('df2\n',df2); print('===========')
print('df1 < df2\n',df1 < df2)
执行结果：
df1
c1 c2
t1 3 4
t2 5 6
===========
df2
c1 c2
t1 1 2
t2 7 8
===========
df1 < df2
c1 c2
t1 False False
t2 True True
（2）广播
① DataFrame与数字进行计算
对于DataFrame与数字进行的+、-、*、/、**、//、%、>、<、>=、<=、==、!=等运算，会将这个DataFrame中的每一个元素均与这个数字进行计算，并用这些结果组成一个与原DataFrame结构、行标签、列标签都相同的DataFrame
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,2],[3,4]],columns=['c1','c2'],index=['t1','t2'])
print(df); print('===========')
print(df // 2); print('===========')
print(df < 2)
执行结果：
c1 c2
t1 1 2
t2 3 4
===========
c1 c2
t1 0 1
t2 1 2
===========
c1 c2
t1 True False
t2 False False
② DataFrame与一维对象进行计算
DataFrame和DataFrame：
DataFrame和DataFrame之间不存在广播的概念，因为DataFrame本身是二维的，因此无论是几行几列，两个DataFrame之间的计算都属于向量化的范畴，详见本章的“向量化与对齐”的部分
DataFrame和一维list：
DataFrame和一维list之间可以广播的前提：DataFrame的列数等于一维list的长度。广播时，按行广播。
DataFrame和一维numpy.ndarray：
DataFrame和一维numpy.ndarray之间可以广播的前提：DataFrame的列数等于一维numpy.ndarray的长度。广播时，按行广播。
DataFrame和Series：
DataFrame和Series之间可以广播的前提：DataFrame的列数等于Series的长度，且Series的index与DataFrame的columns一一对应（顺序可以不同）。广播时，按行广播，标签相同的项执行对应的计算。
# DataFrame 与 一维list 的广播示例
import numpy as np
import pandas as pd
df = pd.DataFrame([[10,20,30,40],[50,60,70,80]],columns=['c1','c2','c3','c4'],index=['t1','t2'])
li= [1,2,100,100] #可以结果正确
print('查看df\n',df); print('===========')
print('查看li\n',li); print('===========')
print('df + li\n',df + li); print('===========')
print('df > li\n',df > li)
执行结果：
查看df
c1 c2 c3 c4
t1 10 20 30 40
t2 50 60 70 80
===========
查看li
[1, 2, 100, 100]
===========
df + li
c1 c2 c3 c4
t1 11 22 130 140
t2 51 62 170 180
===========
df > li
c1 c2 c3 c4
t1 True True False False
t2 True True False False
# DataFrame 与 一维numpy.ndarray 的广播示例
import numpy as np
import pandas as pd
df = pd.DataFrame([[10,20,30,40],[50,60,70,80]],columns=['c1','c2','c3','c4'],index=['t1','t2'])
arr = np.array([1,2,100,100]) #可以结果正确
print('查看df\n',df); print('===========')
print('查看arr\n',arr); print('===========')
print('df + arr\n',df + arr); print('===========')
print('df > arr\n',df > arr)
执行结果：
查看df
c1 c2 c3 c4
t1 10 20 30 40
t2 50 60 70 80
===========
查看arr
[ 1 2 100 100]
===========
df + arr
c1 c2 c3 c4
t1 11 22 130 140
t2 51 62 170 180
===========
df > arr
c1 c2 c3 c4
t1 True True False False
t2 True True False False
# DataFrame 与 Series 的广播示例
import numpy as np
import pandas as pd
df = pd.DataFrame([[10,20,30,40],[50,60,70,80]],columns=['c1','c2','c3','c4'],index=['t1','t2'])
s1 = pd.Series([1,2,100,100]) # 未定义符合条件的index，结果错误
s2 = pd.Series([100, 100, 1, 2], index=['c3','c4','c1','c2']) # 顺序可以不同，结果依然正确
print('查看df\n',df); print('===========')
print('查看s1\n',s1); print('===========')
print('df + s1（结果错误）\n',df + s1); print('===========')
print('df > s1（结果错误）\n',df > s1); print('===========')
print('查看df\n',df); print('===========')
print('查看s2\n',s2); print('===========')
print('df + s2（结果正确）\n',df + s2); print('===========')
print('df > s2（结果正确）\n',df > s2)
执行结果：
查看df
c1 c2 c3 c4
t1 10 20 30 40
t2 50 60 70 80
===========
查看s1
0 1
1 2
2 100
3 100
dtype: int64
===========
df + s1（结果错误）
c1 c2 c3 c4 0 1 2 3
t1 NaN NaN NaN NaN NaN NaN NaN NaN
t2 NaN NaN NaN NaN NaN NaN NaN NaN
===========
df > s1（结果错误）
c1 c2 c3 c4 0 1 2 3
t1 False False False False False False False False
t2 False False False False False False False False
===========
查看df
c1 c2 c3 c4
t1 10 20 30 40
t2 50 60 70 80
===========
查看s2
c3 100
c4 100
c1 1
c2 2
dtype: int64
===========
df + s2（结果正确）
c1 c2 c3 c4
t1 11 22 130 140
t2 51 62 170 180
===========
df > s2（结果正确）
c1 c2 c3 c4
t1 True True False False
t2 True True False False
8. DataFrame的修改、变形、转换
（1）增加一行、增加一列
① 基于df.loc[]增加一行、增加一列
语法：
df.loc['新行标签'] = data # 增加一行
df.loc[:,'新列标签'] = data # 增加一列
df.loc['新行标签','旧列标签'] = data # 增加一行（仅对部分元素赋值，未赋值元素的是NaN）
df.loc['旧行标签','新列标签'] = data # 增加一列（仅对部分元素赋值，未赋值元素的是NaN）
df.loc['新行标签','新列标签'] = data # 增加一行和一列（仅对部分元素赋值，未赋值元素的是NaN）
代码示例：
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,2],[3,4]],columns=['c1','c2'],index=['t1','t2'])
print(df); print('==============')
df.loc['t3'] = [5, 6]
print(df); print('==============')
df.loc[:,'c3'] = [7, 8, 9]
print(df); print('==============')
df.loc['t4','c2'] = 10
print(df); print('==============')
df.loc['t2','c4'] = 11
print(df); print('==============')
df.loc['t5','c5'] = 12
print(df); print('==============')
print(df)
执行结果：
c1 c2
t1 1 2
t2 3 4
==============
c1 c2
t1 1 2
t2 3 4
t3 5 6
==============
c1 c2 c3
t1 1 2 7
t2 3 4 8
t3 5 6 9
==============
c1 c2 c3
t1 1.0 2.0 7.0
t2 3.0 4.0 8.0
t3 5.0 6.0 9.0
t4 NaN 10.0 NaN
==============
c1 c2 c3 c4
t1 1.0 2.0 7.0 NaN
t2 3.0 4.0 8.0 11.0
t3 5.0 6.0 9.0 NaN
t4 NaN 10.0 NaN NaN
==============
c1 c2 c3 c4 c5
t1 1.0 2.0 7.0 NaN NaN
t2 3.0 4.0 8.0 11.0 NaN
t3 5.0 6.0 9.0 NaN NaN
t4 NaN 10.0 NaN NaN NaN
t5 NaN NaN NaN NaN 12.0
==============
c1 c2 c3 c4 c5
t1 1.0 2.0 7.0 NaN NaN
t2 3.0 4.0 8.0 11.0 NaN
t3 5.0 6.0 9.0 NaN NaN
t4 NaN 10.0 NaN NaN NaN
t5 NaN NaN NaN NaN 12.0
② 基于df[]增加一列
语法：df['列标签'] = data
data的长度必须等于df的行数，data可以是list、tuple、range()、numpy.ndarray、Series、DataFrame
注意：当data为Series或DataFrame时，必须为其定义与df相对应的index（顺序可以不同，Pandas会自动根据标签进行匹配），如果不写index，由于DataFrame的自动对齐，会导致新增的值都是NaN
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,3],[2,4]],columns=['c1','c2'],index=['t1','t2'])
print(df); print('==============')
print('list、tuple、range()的情况略'); print('==============')
df['c3'] = np.array([5,6])
print(df); print('==============')
df['c4'] = pd.Series([7,8],index=['t2','t1']) # 给Series定义正确的index，顺序无所谓
print(df); print('==============')
df['c5'] = pd.Series([9,10]) # 未给Series定义index，错误
print(df); print('==============')
df['c6'] = pd.DataFrame([11,12],index=['t2','t1']) # 给DataFrame定义正确的index，顺序无所谓
print(df); print('==============')
df['c7'] = pd.DataFrame([13,14]) # 未给DataFrame定义index，错误
print(df)
执行结果：
c1 c2
t1 1 3
t2 2 4
==============
list、tuple、range()的情况略
==============
c1 c2 c3
t1 1 3 5
t2 2 4 6
==============
c1 c2 c3 c4
t1 1 3 5 8
t2 2 4 6 7
==============
c1 c2 c3 c4 c5
t1 1 3 5 8 NaN
t2 2 4 6 7 NaN
==============
c1 c2 c3 c4 c5 c6
t1 1 3 5 8 NaN 12
t2 2 4 6 7 NaN 11
==============
c1 c2 c3 c4 c5 c6 c7
t1 1 3 5 8 NaN 12 NaN
t2 2 4 6 7 NaN 11 NaN
③ 基于df.append()增加一行
语法：df.append(series)，详见本章二、Pandas模块 - 12. DataFrame的合并 - （2）df.append()
④ 基于df.assign()增加一列
语法：df = df.assign(新列标签索引=表达式)
常用于根据现有的列进行表达式计算，产生新的列
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,2],[3,4]],columns=['c1','c2'],index=['t1','t2'])
print(df); print('==============')
df = df.assign(c3 = df['c1']/df['c2'])
print(df)
执行结果：
c1 c2
t1 1 2
t2 3 4
==============
c1 c2 c3
t1 1 2 0.50
t2 3 4 0.75
（3）删除若干行、删除若干列
① 仅删除一列：del
语法：
- 当列标签为label index（列标签索引）时，只能使用label index删：
del df['列标签索引'] - 当列标签为position index（列位置索引）时，只能使用position index删：
del df[列位置索引]
注意：del方法只能用于删除一列，不能使用索引、切片的方法删除多列
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,3,5,7,9],[2,4,6,8,10]])
print(df); print('==============')
del df[1]
print(df); print('==============')
df.columns=['c1','c2','c3','c4']
df.index=['t1','t2']
print(df); print('==============')
del df['c2']
print(df)
执行结果：
0 1 2 3 4
0 1 3 5 7 9
1 2 4 6 8 10
==============
0 2 3 4
0 1 5 7 9
1 2 6 8 10
==============
c1 c2 c3 c4
t1 1 5 7 9
t2 2 6 8 10
==============
c1 c3 c4
t1 1 7 9
t2 2 8 10
② 删除若干行、删除若干列：df.drop()
语法：
-
当标签为label index（标签索引）时，只能使用label index删：
df.drop('标签索引'或['标签索引','标签索引',...], axis=0, inplace=False) -
当标签为position index（位置索引）时，只能使用position index删：
df.drop(位置索引或[位置索引,位置索引,...], axis=0, inplace=False)
参数：
- axis：默认为0，按行删；axis=1时，按列删
- inplace：默认值为False，不对df本身进行修改；inplace=True时，直接对df进行修改
import numpy as np
import pandas as pd
df = pd.DataFrame(np.arange(100,149).reshape(7, 7))
print(df); print('==============')
df = df.drop(0) # 删除第0行
df = df.drop([1,2]) # 删除第1、2行
print(df); print('==============')
df = df.drop(0,axis=1) # 删除第0列
df = df.drop([1,2],axis=1) # 删除第1、2列
print(df); print('==============')
df.columns=['c1','c2','c3','c4']
df.index=['t1','t2','t3','t4']
print(df); print('==============')
df = df.drop('t1') # 删除't1'行
df = df.drop(['t2','t3']) # 删除't2'、't3'列
print(df); print('==============')
df = df.drop('c1',axis=1) # 删除'c1'行
df = df.drop(['c2','c3'],axis=1) # 删除'c2'、'c3'列
print(df)
执行结果：
0 1 2 3 4 5 6
0 100 101 102 103 104 105 106
1 107 108 109 110 111 112 113
2 114 115 116 117 118 119 120
3 121 122 123 124 125 126 127
4 128 129 130 131 132 133 134
5 135 136 137 138 139 140 141
6 142 143 144 145 146 147 148
==============
0 1 2 3 4 5 6
3 121 122 123 124 125 126 127
4 128 129 130 131 132 133 134
5 135 136 137 138 139 140 141
6 142 143 144 145 146 147 148
==============
3 4 5 6
3 124 125 126 127
4 131 132 133 134
5 138 139 140 141
6 145 146 147 148
==============
c1 c2 c3 c4
t1 124 125 126 127
t2 131 132 133 134
t3 138 139 140 141
t4 145 146 147 148
==============
c1 c2 c3 c4
t4 145 146 147 148
==============
c4
t4 148
（3）修改DataFrame数据的值
首先使用df[]、df.loc[]、df.iloc[]、df.ix[]等方法选择相应的数据，然后使用等号赋值即可
特别地，可以对布尔值索引的筛选结果进行赋值修改，如：
# 将所有负数转化为正数
df[df<0] = -df
# 将所有PE小于0的PE数据赋值为1000
df.loc[df['PE'<0],'PE'] = 1000
# 新增一列new_column，并且令PE为负的行的new_column列为0（PE非负的行的new_column列的值将是NaN）
df.loc[df['PE']<0,'new_column'] = 0
（4）对DataFrame数据的值进行替换：df.replace()
语法：
df.replace('替换前的值', '替换后的值', inplace=False) # 单个值的替换
df.replace({'旧1':'新1','旧2':'新2'...}, inplace=False) # 多个值的替换
若要同时进行多个值的替换，可以使用字典将替换前的值、替换后的值组成键值对
参数inplace：默认值为False，不对df本身进行修改；inplace=True时，直接对df进行修改
注意：仅对值进行替换，不会对标签索引或位置索引进行替换
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,2],[3,4]])
df.columns=[3,4]
print(df); print('===========')
df.replace(3,33,inplace=True)
print(df); print('===========')
df.replace({2:22,4:44},inplace=True)
print(df)
执行结果：
3 4
0 1 2
1 3 4
===========
3 4
0 1 2
1 33 4
===========
3 4
0 1 22
1 33 44
（5）按指定列或行的数据值排序：df.sort_values()
语法：df.sort_values(by, axis=0, ascending=True, inplace=False)
参数：
- by：可以是列标签或行标签（单列排序），也可以是列标签组成的list或行标签组成的list（多列排序），注意by与axis的对应关系（axis=0时by=
'列标签'或['列标签1','列标签2',...]，axis=1时by='行标签'或['行标签1','行标签2',...]） - axis：默认值为0，按指定列的数据值排序；axis=1时，按指定行的数据值排序
- ascending：默认值为True，升序排列；ascending=False时，降序排列
- inplace：默认值为False，不对df本身进行修改；inplace=True时，直接对df进行修改
import numpy as np
import pandas as pd
np.random.seed(1)
arr = np.random.randint(1,100,(4,4))
df = pd.DataFrame(arr,columns=['c1','c2','c3','c4'])
df.index = pd.date_range('2019-1-31', periods=4, freq='M')
print('df\n',df); print('===========')
# 按c1列的值的升序排列
df = df.sort_values(by='c1')
# df.sort_values(by='c1',inplace=True) # 这样写也行
print('按c1列的值的升序排列\n',df); print('===========')
# 按2019-04-30行的值的降序排列
df = df.sort_values(by=pd.datetime(2019,4,30),axis=1,ascending=False)
# df.sort_values(by=pd.datetime(2019,4,30),axis=1,ascending=False,inplace=True) # 这样写也行
print('按2019-04-30行的值的降序排列\n',df)
执行结果：
df
c1 c2 c3 c4
2019-01-31 38 13 73 10
2019-02-28 76 6 80 65
2019-03-31 17 2 77 72
2019-04-30 7 26 51 21
===========
按c1列的值的升序排列
c1 c2 c3 c4
2019-04-30 7 26 51 21
2019-03-31 17 2 77 72
2019-01-31 38 13 73 10
2019-02-28 76 6 80 65
===========
按2019-04-30行的值的降序排列
c3 c2 c4 c1
2019-04-30 51 26 21 7
2019-03-31 77 2 72 17
2019-01-31 73 13 10 38
2019-02-28 80 6 65 76
（6）按DataFrame的标签排序：df.sort_index()
语法：df.sort_index(axis=0, ascending=True, inplace=False)
参数：
- axis：默认值为0，按行标签排序；axis=1时，按列标签排序
- ascending：默认值为True，升序排列；ascending=False时，降序排列
- inplace：默认值为False，不对df本身进行修改；inplace=True时，直接对df进行修改
import numpy as np
import pandas as pd
np.random.seed(1)
arr = np.random.randint(1,100,(4,4))
df = pd.DataFrame(arr,columns=['c1','c2','c3','c4'])
df.index = pd.date_range('2019-1-31', periods=4, freq='M')
print('df\n',df); print('===========')
# 按行标签降序排列
df = df.sort_index(ascending=False)
# df.sort_index(ascending=False,inplace=True) # 这样写也行
print('按行标签降序排列\n',df); print('===========')
# 按列标签降序排列
df = df.sort_index(axis=1, ascending=False)
# df.sort_index(axis=1, ascending=False, inplace=True) # 这样写也行
print('按列标签降序排列\n',df)
执行结果：
df
c1 c2 c3 c4
2019-01-31 38 13 73 10
2019-02-28 76 6 80 65
2019-03-31 17 2 77 72
2019-04-30 7 26 51 21
===========
按行标签降序排列
c1 c2 c3 c4
2019-04-30 7 26 51 21
2019-03-31 17 2 77 72
2019-02-28 76 6 80 65
2019-01-31 38 13 73 10
===========
按列标签降序排列
c4 c3 c2 c1
2019-04-30 21 51 26 7
2019-03-31 72 77 2 17
2019-02-28 65 80 6 76
2019-01-31 10 73 13 38
（7）自定义列标签和行标签：df.columns和df.index
这两个属性都支持对其整体进行重新赋值，但不支持对其中的元素进行修改（会报错），详见本章“DataFrame对象的属性”
（8）将某一列的值设置为行标签索引：df.set_index()
语法：df.set_index('选中列的列标签', inplace=False)
将某一列的值设置为行标签索引（注意：指定列是被“剪切”到最左边当索引的，不是“复制”）
参数inplace：默认值为False（不替换原df，须使用一个新的变量进行接收）；值为True时，直接在原df上修改
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,'a',3+4j],[2,'b',5+6j]],columns=['c1','c2','c3'],index=['t1','t2'])
print(df); print('===========')
df.set_index('c2', inplace = True)
print(df)
执行结果：
c1 c2 c3
t1 1 a 3.0+4.0j
t2 2 b 5.0+6.0j
===========
c1 c3
c2
a 1 3.0+4.0j
b 2 5.0+6.0j
（9）重置行索引：df.reset_index()
语法：df.reset_index(inplace=False)
将行标签索引删除，并将其保存为DataFrame数据的第一列（该列对应的列标签索引为df.index.name），df.index则被重置为0、1、2……的位置索引
参数inplace：默认值为False（不替换原df，须使用一个新的变量进行接收）；值为True时，直接在原df上修改
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,3,5,7],[2,4,6,8]],columns=['c1','c2','c3','c4'],index=['t1','t2'])
df.index.name = 'myindex' # 为df.index这个Series设置名字
print(df); print('===========')
df.reset_index(inplace=True)
print(df)
执行结果：
c1 c2 c3 c4
myindex
t1 1 3 5 7
t2 2 4 6 8
===========
myindex c1 c2 c3 c4
0 t1 1 3 5 7
1 t2 2 4 6 8
（10）对列标签进行重命名：df.rename()
语法：df.rename(columns={'原列标签':'新列标签',...},inplace=False)
对列标签进行重命名。注意此方法仅能修改列标签columns，不能修改行标签index。
参数：
- columns：一个字典，里面是原列标签和新列标签组成的键值对
- inplace：默认值为False（不替换原df，须使用一个新的变量进行接收）；值为True时，直接在原df上修改
import numpy as np
import pandas as pd
arr = np.array([[1,2,3,4],[5,6,7,8]])
df1 = pd.DataFrame(arr,columns=['c1','c2','c3','c4'],index=['t1','t2'])
print("查看df1\n",df1); print('===========')
df2 = df1.rename(columns={'c2':'哈','c5':'嘿','t2':'哼'})
print("查看df2\n",df2)
执行结果：
查看df1
c1 c2 c3 c4
t1 1 2 3 4
t2 5 6 7 8
===========
查看df2
c1 哈 c3 c4
t1 1 2 3 4
t2 5 6 7 8
（11）修改某列的数据类型：astype()
语法：df['列标签'] = df['列标签'].astype('新的数据类型')
由于astype()不会对原对象本身进行修改，因此只能通过这样的赋值操作来实现修改
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,2.9],[3,4.9]],columns=['c1','c2'],index=['t1','t2'])
print(df); print('==============')
print(df.dtypes); print('==============')
df['c1'] = df['c1'].astype('float') # 将c1列变为float
df['c2'] = df['c2'].astype('int') # 将c2列变为int
print(df); print('==============')
print(df.dtypes)
执行结果：
c1 c2
t1 1 2.9
t2 3 4.9
==============
c1 int64
c2 float64
dtype: object
==============
c1 c2
t1 1.0 2
t2 3.0 4
==============
c1 float64
c2 int32
dtype: object
（12）删除值重复的行：df.drop_duplicates()
语法：df.drop_duplicates(subset=None, keep='first', inplace=False)
删除值重复的行，返回一个DataFrame
参数：
- subset：子集，默认为None，此时两行的所有列的值都相等，才认为这两行重复；当
subset='列标签'或subset=['列标签','列标签',...]时，只要指定的列的值相等，就认为这两行重复 - keep：重复时保留哪一行，默认为'first'，保留第一行；当keep='last'时，保留最后一行；当keep=False时，不保留
- inplace：默认值为False（不替换原df，须使用一个新的变量进行接收）；值为True时，直接在原df上修改
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,2,3],[1,2,3],[1,2,3],[1,2,4]],columns=['c1','c2','c3'],index=['t1','t2','t3','t4'])
print(df); print('===========')
print(df.drop_duplicates()); print('===========')
print(df.drop_duplicates(keep='last')); print('===========')
print(df.drop_duplicates(keep=False)); print('===========')
print(df.drop_duplicates(subset=['c1','c2']))
执行结果：
c1 c2 c3
t1 1 2 3
t2 1 2 3
t3 1 2 3
t4 1 2 4
===========
c1 c2 c3
t1 1 2 3
t4 1 2 4
===========
c1 c2 c3
t3 1 2 3
t4 1 2 4
===========
c1 c2 c3
t4 1 2 4
===========
c1 c2 c3
t1 1 2 3
（13）将数据的值整体平移若干行（或列）：df.shift()
语法：df.shift(periods=1,axis=0)
返回一个DataFrame，其行标签、列标签与df均相同，值向某方向平移了若干行（或列），平移导致空缺的行（或列）使用NaN填充
参数：
- periods：值被平移的行数或列数，默认为1（int）
- axis：默认值为0，纵向平移；axis=1时横向平移
注意：
-
period和axis两个参数共同决定了平移的方向：
axis=0 axis=1 period<0 向上平移 向左平移 period=0 不平移 不平移 period>0 向下平移 向右平移 仅对DataFrame的值进行平移，行标签、列标签不跟着平移
常使用df/df.shift()计算资产价格每日收益率，见下例：
import numpy as np
import pandas as pd
df = pd.DataFrame({'600001': [10,11,12,13,14],'600002': [20,21,22,23,24],'600003':[30,31,32,33,34]},index=['t1','t2','t3','t4','t5'])
print('df\n',df); print('-----------')
print('向下平移1行：df.shift()\n',df.shift()); print('-----------')
print('每日收益率df/df.shift()-1\n',df/df.shift()-1); print('===========')
print('向上平移1行：df.shift(-1)\n',df.shift(-1)); print('-----------')
print('向右平移1行：df.shift(1,axis=1)\n',df.shift(1,axis=1)); print('-----------')
print('向左平移1行：df.shift(-1,axis=1)\n',df.shift(-1,axis=1))
执行结果：
df
600001 600002 600003
t1 10 20 30
t2 11 21 31
t3 12 22 32
t4 13 23 33
t5 14 24 34
-----------
向下平移1行：df.shift()
600001 600002 600003
t1 NaN NaN NaN
t2 10.0 20.0 30.0
t3 11.0 21.0 31.0
t4 12.0 22.0 32.0
t5 13.0 23.0 33.0
-----------
每日收益率df/df.shift()-1
600001 600002 600003
t1 NaN NaN NaN
t2 0.100000 0.050000 0.033333
t3 0.090909 0.047619 0.032258
t4 0.083333 0.045455 0.031250
t5 0.076923 0.043478 0.030303
===========
向上平移1行：df.shift(-1)
600001 600002 600003
t1 11.0 21.0 31.0
t2 12.0 22.0 32.0
t3 13.0 23.0 33.0
t4 14.0 24.0 34.0
t5 NaN NaN NaN
-----------
向右平移1行：df.shift(1,axis=1)
600001 600002 600003
t1 NaN 10.0 20.0
t2 NaN 11.0 21.0
t3 NaN 12.0 22.0
t4 NaN 13.0 23.0
t5 NaN 14.0 24.0
-----------
向左平移1行：df.shift(-1,axis=1)
600001 600002 600003
t1 20.0 30.0 NaN
t2 21.0 31.0 NaN
t3 22.0 32.0 NaN
t4 23.0 33.0 NaN
t5 24.0 34.0 NaN
（14）将DataFrame转换为字典：df.to_dict()
语法：df.to_dict(orient='dict')
将DataFrame转换为字典
参数orient：转换成的字典的类型，默认值为'dict'，还可以是'list'、'series'、'split'、'records'、'index'，每个参数的效果见示例代码：
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,2],[3,4]],columns=['c1','c2'],index=['t1','t2'])
print(df); print('===========')
print(df.to_dict(orient='dict')); print('===========')
print(df.to_dict(orient='list')); print('===========')
print(df.to_dict(orient='series')); print('===========')
print(df.to_dict(orient='split')); print('===========')
print(df.to_dict(orient='records')); print('===========')
print(df.to_dict(orient='index'))
执行结果：
c1 c2
t1 1 2
t2 3 4
===========
{'c1': {'t1': 1, 't2': 3}, 'c2': {'t1': 2, 't2': 4}}
===========
{'c1': [1, 3], 'c2': [2, 4]}
===========
{'c1': t1 1
t2 3
Name: c1, dtype: int64, 'c2': t1 2
t2 4
Name: c2, dtype: int64}
===========
{'index': ['t1', 't2'], 'columns': ['c1', 'c2'], 'data': [[1, 2], [3, 4]]}
===========
[{'c1': 1, 'c2': 2}, {'c1': 3, 'c2': 4}]
===========
{'t1': {'c1': 1, 'c2': 2}, 't2': {'c1': 3, 'c2': 4}}
（15）使用DataFrame中的若干列构建数据透视表：df.pivot()
语法：df.pivot(index='列标签', columns='列标签', values='列标签'或['列标签','列标签'...])
返回一个数据透视表形式的DataFrame
参数：
- index：数据透视表的y轴（str）
- columns：数据透视表的x轴（str）
- values：数据透视表的数据值（str或list）
import numpy as np
import pandas as pd
df = pd.DataFrame({'foo': ['one', 'one', 'one', 'two', 'two','two'],
'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
'baz': [1, 2, 3, 4, 5, 6],
'zoo': ['x', 'y', 'z', 'q', 'w', 't']})
print(df); print('===========')
df1 = df.pivot(index='foo', columns='bar', values='baz')
print(df1); print(type(df1)); print('===========')
df2 = df.pivot(index='foo', columns='bar', values=['baz', 'zoo'])
print(df2); print(type(df2))
执行结果：
foo bar baz zoo
0 one A 1 x
1 one B 2 y
2 one C 3 z
3 two A 4 q
4 two B 5 w
5 two C 6 t
===========
bar A B C
foo
one 1 2 3
two 4 5 6
<class 'pandas.core.frame.DataFrame'>
===========
baz zoo
bar A B C A B C
foo
one 1 2 3 x y z
two 4 5 6 q w t
<class 'pandas.core.frame.DataFrame'>
（16）对层次化索引的DataFrame进行变形（行标签与列标签的转换）：df.unstack()和df.stack()
详见本章“13.层次化索引 - （3）使用unstack()和stack()对层次化索引的Series和DataFrame进行变形（行标签与列标签的转换）”
9. DataFrame的空值（NaN）处理
（1）手动输入NaN的方法
- 输入numpy.nan
- 将None作为list中的一个元素，并使用此list创建DataFrame，则相应位置的None会自动变为NaN
（2）df.isnull(), df.isna(), df.notna()
语法1：df.isnull(), df.isna()
判断每个df的每个元素是否为NaN（是NaN时返回True），返回一个结构与df相同的、由布尔值组成的DataFrame
语法2：df.notna()
判断每个df的每个元素是否为NaN（不是NaN时返回True），返回一个结构与df相同的、由布尔值组成的DataFrame
import numpy as np
import pandas as pd
df = pd.DataFrame([[np.nan,2],[3,4]],columns=['c1','c2'],index=['t1','t2'])
print(df); print('===========')
print(df.isnull()); print('===========')
print(df.isna()); print('===========')
print(df.notna())
执行结果：
c1 c2
t1 NaN 2
t2 3.0 4
===========
c1 c2
t1 True False
t2 False False
===========
c1 c2
t1 True False
t2 False False
===========
c1 c2
t1 False True
t2 True True
（3）df.dropna()
语法：df.dropna(axis=0, how='any', inplace=False)
删除df中含有NaN的行（或列）
参数：
- axis：默认值为0，按行删除；axis=1时按列删除
- how：默认值为'any'，只要这一行（或列）有一个元素是NaN，就删除整行（或列）；当how='all'时，必须这一行（或列）所有元素都是NaN，才删除整行（或列）
- inplace：默认值为False，此时不会对df本身进行修改，需要额外定义一个变量来接收结果；而当inplace=True时，则会直接对df本身进行修改
import numpy as np
import pandas as pd
df = pd.DataFrame([[np.nan,2],[3,4]],columns=['c1','c2'],index=['t1','t2'])
print(df); print('===========')
df.dropna(inplace=True)
print(df)
执行结果：
c1 c2
t1 NaN 2
t2 3.0 4
===========
c1 c2
t2 3.0 4
（4）df.fillna()、df.ffill()、df.bfill()
对df中的NaN按照一定的规则进行替换
语法：df.fillna(value=None, method=None, axis=0, inplace=False)，它和df.ffill(axis=)与df.bfill(axis=)的关系见下面“注意”中的表格
参数：
- value可以有两种形式：
- value可以是一个固定的值，表示将df中的所有NaN统一替换成这个值
- value可以是一个字典，字典的键是df的列标签，字典的值是将该列中NaN替换成的值（可以实现对不同的列中的NaN替换成不同的值）
- value还可以是一个Series或DataFrame，此时遇到NaN会寻找对应位置的元素进行填充
- method是填充方法，默认为None；当
method='ffill'或method='pad'时，向前填充，与df.ffill(axis=)等价；当method='bfill'时，向后填充，与df.bfill(axis=)等价 - axis：坐标轴方向，默认值为0，纵向；axis=1时为横向
- inplace默认值为False，此时不会对df本身进行修改，需要额外定义一个变量来接收结果；而当inplace=True时，则会直接对df本身进行修改
注意：
value和method两个参数能且只能输入一个，即二者不能同时为None，也不能同时不为None，否则报错
-
当使用method时，method和axis两个参数共同决定了寻找填充值的方向：
method='ffill' method='bfill' axis=0 取上方单元格的值填充NaN
等价于df.ffill()取下方单元格的值填充NaN
等价于df.bfill()axis=1 取左侧单元格的值填充NaN
等价于df.ffill(axis=1)取右侧单元格的值填充NaN
等价于df.bfill(axis=1)当指向的单元格仍为NaN时，继续越过该单元格向相同方向寻找填充值，若直到DataFrame的边界都是NaN，则不再进行填充，保留这些NaN
import numpy as np
import pandas as pd
df = pd.DataFrame([[np.nan,101,102,np.nan],
[110,np.nan,112,113],
[120,121,np.nan,123],
[np.nan,131,132,np.nan]],
columns=['c1','c2','c3','c4'],index=['t1','t2','t3','t4'])
df0 = df.fillna(0)
df1 = df.fillna({'c1':-1,'c4':-4})
df2 = df.fillna(method='ffill')
df3 = df.fillna(method='bfill')
df4 = df.fillna(method='ffill', axis=1)
df5 = df.fillna(method='bfill', axis=1)
df6 = df.ffill()
df7 = df.bfill()
df8 = df.ffill(axis=1)
df9 = df.bfill(axis=1)
print('df\n',df); print('===========')
print('df0(替换为0)\n',df0); print('===========')
print('df1(基于字典)\n',df1); print('===========')
print('df2(向上)\n',df2); print('===========')
print('df3(向下)\n',df3); print('===========')
print('df4(向左)\n',df4); print('===========')
print('df5(向右)\n',df5); print('===========')
print('df6(向上)\n',df6); print('===========')
print('df7(向下)\n',df7); print('===========')
print('df8(向左)\n',df8); print('===========')
print('df9(向右)\n',df9)
执行结果：
df
c1 c2 c3 c4
t1 NaN 101.0 102.0 NaN
t2 110.0 NaN 112.0 113.0
t3 120.0 121.0 NaN 123.0
t4 NaN 131.0 132.0 NaN
===========
df0(替换为0)
c1 c2 c3 c4
t1 0.0 101.0 102.0 0.0
t2 110.0 0.0 112.0 113.0
t3 120.0 121.0 0.0 123.0
t4 0.0 131.0 132.0 0.0
===========
df1(基于字典)
c1 c2 c3 c4
t1 -1.0 101.0 102.0 -4.0
t2 110.0 NaN 112.0 113.0
t3 120.0 121.0 NaN 123.0
t4 -1.0 131.0 132.0 -4.0
===========
df2(向上)
c1 c2 c3 c4
t1 NaN 101.0 102.0 NaN
t2 110.0 101.0 112.0 113.0
t3 120.0 121.0 112.0 123.0
t4 120.0 131.0 132.0 123.0
===========
df3(向下)
c1 c2 c3 c4
t1 110.0 101.0 102.0 113.0
t2 110.0 121.0 112.0 113.0
t3 120.0 121.0 132.0 123.0
t4 NaN 131.0 132.0 NaN
===========
df4(向左)
c1 c2 c3 c4
t1 NaN 101.0 102.0 102.0
t2 110.0 110.0 112.0 113.0
t3 120.0 121.0 121.0 123.0
t4 NaN 131.0 132.0 132.0
===========
df5(向右)
c1 c2 c3 c4
t1 101.0 101.0 102.0 NaN
t2 110.0 112.0 112.0 113.0
t3 120.0 121.0 123.0 123.0
t4 131.0 131.0 132.0 NaN
===========
df6(向上)
c1 c2 c3 c4
t1 NaN 101.0 102.0 NaN
t2 110.0 101.0 112.0 113.0
t3 120.0 121.0 112.0 123.0
t4 120.0 131.0 132.0 123.0
===========
df7(向下)
c1 c2 c3 c4
t1 110.0 101.0 102.0 113.0
t2 110.0 121.0 112.0 113.0
t3 120.0 121.0 132.0 123.0
t4 NaN 131.0 132.0 NaN
===========
df8(向左)
c1 c2 c3 c4
t1 NaN 101.0 102.0 102.0
t2 110.0 110.0 112.0 113.0
t3 120.0 121.0 121.0 123.0
t4 NaN 131.0 132.0 132.0
===========
df9(向右)
c1 c2 c3 c4
t1 101.0 101.0 102.0 NaN
t2 110.0 112.0 112.0 113.0
t3 120.0 121.0 123.0 123.0
t4 131.0 131.0 132.0 NaN
（5）df.interpolate()
interpolate：v.插值
语法：df.interpolate(method='linear', axis=0, inplace=False)
使用插值法对df中的NaN进行替换
参数：
- method：插值方法，默认为
'linear'，线性插值，也可以选择其他方法 - axis：插值方向，默认为0，纵向插值；axis=0时为横向插值
- inplace默认值为False，此时不会对df本身进行修改，需要额外定义一个变量来接收结果；而当inplace=True时，则会直接对df本身进行修改
线性插值时，df边界行（或边界列）上的NaN的处理方法：
- 若axis=0，则上边界行上的NaN保持不变，下边界行上的NaN取其上方的值对NaN进行替换（向上填充）
- 若axis=1，则左边界列上的NaN保持不变，右边界列上的NaN取其左侧的值对NaN进行替换（向左填充）
关于时间序列低频调整为高频（升采样）的插值法，见本章“14. Pandas中的时间相关格式及方法-（9）df.resample()-低频调整为高频（升采样）：通过线性插值实现”
import numpy as np
import pandas as pd
df = pd.DataFrame([[10,np.nan,30],[np.nan,50,np.nan],[70,np.nan,90]],columns=['c1','c2','c3'],index=['t1','t2','t3'])
df1 = df.interpolate()
df2 = df.interpolate(axis=1)
print('df\n',df); print('===========')
print('df1\n',df1); print('===========')
print('df2\n',df2)
执行结果：
df
c1 c2 c3
t1 10.0 NaN 30.0
t2 NaN 50.0 NaN
t3 70.0 NaN 90.0
===========
df1
c1 c2 c3
t1 10.0 NaN 30.0
t2 40.0 50.0 60.0
t3 70.0 50.0 90.0
===========
df2
c1 c2 c3
t1 10.0 20.0 30.0
t2 NaN 50.0 50.0
t3 70.0 80.0 90.0
10. DataFrame对象的方法和Pandas模块的方法
（0）一元通用函数
由于Pandas底层是NumPy，所以大部分numpy模块中的通用函数都适用于df，如：
求平方根：np.sqrt(df)
四舍五入：df.round(n)、np.round(df,n)
（1）一元通用函数补充
① 判断df中的每个元素是否在指定列表里
语法：df.isin(list)
返回一个与df结构相同的、由布尔值组成的DataFrame
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,2],[3,4]],columns=['c1','c2'],index=['t1','t2'])
print(df.isin([2,3,5,7,11,13,17]))
执行结果
c1 c2
t1 False True
t2 True False
② 计算纵向相对百分比变化
语法：为df.pct_change(periods=1)
返回一个DataFrame，里面的每一项都是相对百分比变化，即：
\[新的DataFrame第m行n列的值=\frac{df第m行n列的值}{df第(m-periods)行n列的值}
\]
\]
periods是从分子到分母所移动的行数，默认值为1。当periods>0时，相当于用某单元格的值 / 它上面某单元格的值；当periods<0时，相当于用某单元格的值 / 它下面某单元格的值
常使用df.pct_change()计算资产价格的每日收益率
import numpy as np
import pandas as pd
df = pd.DataFrame({'600001': [10,11,12,13,14],'600002': [20,21,22,23,24],'600003':[30,31,32,33,34]},index=['t1','t2','t3','t4','t5'])
print('df\n',df); print('===========')
print(df.pct_change()); print('===========') # 常见的收益率计算方式
print(df.pct_change(-1))
执行结果：
df
600001 600002 600003
t1 10 20 30
t2 11 21 31
t3 12 22 32
t4 13 23 33
t5 14 24 34
===========
600001 600002 600003
t1 NaN NaN NaN
t2 0.100000 0.050000 0.033333
t3 0.090909 0.047619 0.032258
t4 0.083333 0.045455 0.031250
t5 0.076923 0.043478 0.030303
===========
600001 600002 600003
t1 -0.090909 -0.047619 -0.032258
t2 -0.083333 -0.045455 -0.031250
t3 -0.076923 -0.043478 -0.030303
t4 -0.071429 -0.041667 -0.029412
t5 NaN NaN NaN
（2）二元通用函数
由于Pandas底层是NumPy，所以大部分numpy模块中的通用函数都适用于df
（3）统计相关方法
① df.min()和df.idxmin()
语法：df.min(axis=0)
按列（或按行）计算给定的DataFrame中的最小值，返回一个Series
参数axis：
- 默认值为0，即按列求最小。当给定的DataFrame为m行n列时，返回的Series长度为n，其索引为DataFrame的列标签，值为该列的最小值
- 若axis=1，则按行求最小。当给定的DataFrame为m行n列时，返回的Series长度为m，其索引为DataFrame的行标签，值为该行的最小值
语法：df.idxmin(axis=0)
按列（或按行）计算给定的DataFrame中的最小值所对应的行标签（或列标签），返回一个Series
参数axis：默认值为0，即按列求最小；若axis=1，则按行求最小
注意：df.argmin()方法已弃用，改为df.idxmin()方法
import numpy as np
import pandas as pd
arr = np.array([[1,2],[4,3]])
df = pd.DataFrame(arr,columns=['c1','c2'],index=['t1','t2'])
print(df); print('===========')
print(df.min()); print('-----------') # 寻找每一列最小的值
print(df.min(axis=1)); print('===========') # 寻找每一行最小的值
print(df.idxmin()); print('-----------') # 寻找每一列最小的值对应的行标签
print(df.idxmin(axis=1)) # 寻找每一行最小的值对应的行标签
执行结果：
c1 c2
t1 1 2
t2 4 3
===========
c1 1
c2 2
dtype: int32
-----------
t1 1
t2 3
dtype: int32
===========
c1 t1
c2 t1
dtype: object
-----------
t1 c1
t2 c2
dtype: object
② df.max()和df.idxmax()
语法：df.max(axis=0)
按列（或按行）计算给定的DataFrame中的最大值，返回一个Series
参数axis：
- 默认值为0，即按列求最大。当给定的DataFrame为m行n列时，返回的Series长度为n，其索引为DataFrame的列标签，值为该列的最大值
- 若axis=1，则按行求最大。当给定的DataFrame为m行n列时，返回的Series长度为m，其索引为DataFrame的行标签，值为该行的最大值
语法：df.idxmax(axis=0)
按列（或按行）计算给定的DataFrame中的最大值所对应的行标签（或列标签），返回一个Series
参数axis：默认值为0，即按列求最大；若axis=1，则按行求最大
注意：df.argmax()方法已弃用，改为df.idxmax()方法
import numpy as np
import pandas as pd
arr = np.array([[1,2],[4,3]])
df = pd.DataFrame(arr,columns=['c1','c2'],index=['t1','t2'])
print(df); print('===========')
print(df.max()); print('-----------') # 寻找每一列最大的值
print(df.max(axis=1)); print('===========') # 寻找每一行最大的值
print(df.idxmax()); print('-----------') # 寻找每一列最大的值对应的行标签
print(df.idxmax(axis=1)) # 寻找每一行最大的值对应的行标签
执行结果：
c1 c2
t1 1 2
t2 4 3
===========
c1 4
c2 3
dtype: int32
-----------
t1 2
t2 4
dtype: int32
===========
c1 t2
c2 t2
dtype: object
-----------
t1 c2
t2 c1
dtype: object
③ df.sum()
语法：df.sum(axis=0)
按列（或按行）对给定的DataFrame中的数据求和，返回一个Series
参数axis：
- 默认值为0，即按列求和。当给定的DataFrame为m行n列时，返回的Series长度为n，其索引为DataFrame的列标签，值为该列所有数据的和
- 若axis=1，则按行求和。当给定的DataFrame为m行n列时，返回的Series长度为m，其索引为DataFrame的行标签，值为该行所有数据的和
import numpy as np
import pandas as pd
arr = np.array([[1,2],[3,4]])
df = pd.DataFrame(arr,columns=['c1','c2'],index=['t1','t2'])
print(df); print('===========')
print(df.sum(),type(df.sum())); print('===========') # 默认按列求和
print(df.sum(axis=1)) # 按行求和
执行结果：
c1 c2
t1 1 2
t2 3 4
===========
c1 4
c2 6
dtype: int64 <class 'pandas.core.series.Series'>
===========
t1 3
t2 7
④ df.mean()
语法：df.mean(axis=0)
按列（或按行）对给定的DataFrame中的数据求算数平均，返回一个Series
参数axis：
- 默认值为0，即按列求平均。当给定的DataFrame为m行n列时，返回的Series长度为n，其索引为DataFrame的列标签，值为该列所有数据的算数平均
- 若axis=1，则按行求平均。当给定的DataFrame为m行n列时，返回的Series长度为m，其索引为DataFrame的行标签，值为该行所有数据的算数平均
import numpy as np
import pandas as pd
arr = np.array([[1,2],[3,4]])
df = pd.DataFrame(arr,columns=['c1','c2'],index=['t1','t2'])
print(df); print('===========')
print(df.mean(),type(df.mean())); print('===========') # 默认按列求平均
print(df.mean(axis=1),type(df.mean())) # 按行求平均
执行结果：
c1 c2
t1 1 2
t2 3 4
===========
c1 2.0
c2 3.0
dtype: float64 <class 'pandas.core.series.Series'>
===========
t1 1.5
t2 3.5
dtype: float64 <class 'pandas.core.series.Series'>
⑤ df.count()
语法：df.count(axis=0)
按列（或按行）统计给定的DataFrame中非空数据的个数，返回一个Series
参数axis：
- 默认值为0，即按列计数。当给定的DataFrame为m行n列时，返回的Series长度为n，其索引为DataFrame的列标签，值为该列非空数据的个数
- 若axis=1，则按行计数。当给定的DataFrame为m行n列时，返回的Series长度为m，其索引为DataFrame的行标签，值为该行非空数据的个数
import numpy as np
import pandas as pd
arr = np.array([[np.nan,2],[3,4]]) # 手动输入NaN的方式
df = pd.DataFrame(arr,columns=['c1','c2'],index=['t1','t2'])
print(df); print('===========')
print(df.count(),type(df.count())); print('===========') # 默认按列计数
print(df.count(axis=1)) # 按行计数
执行结果：
c1 c2
t1 NaN 2.0
t2 3.0 4.0
===========
c1 1
c2 2
dtype: int64 <class 'pandas.core.series.Series'>
===========
t1 1
t2 2
dtype: int64
⑥ 累积计算：df.cumsum()、df.cumprod()、df.cummax()、df.cummin()
语法：df.cumXXX(axis=0)
按列（或按行）计算给定的DataFrame累积和、累积积、累积最大、累积最小，返回一个DataFrame
参数axis：默认值为0，即按列计算；若axis=1，则按行计算
注意：
- 累积最大指从第一个数据到当前数据这段区间内的最大，累积最小同理
- 累积最大、累积最小是DataFrame特有的方法，numpy.ndarray没有这两种方法
- 累积最大常用于计算最大回撤（max drawdown）
- 和numpy.ndarray不同，DataFrame不会将多维数据变为一维再计算其累积值
import numpy as np
import pandas as pd
df = pd.DataFrame({'c1':[1,-2,3,4,-5,6],'c2':[10,20,-30,-40,50,-60]},index=['t1','t2','t3','t4','t5','t6'])
df1 = df.cumsum()
df2 = df.cumsum(axis=1)
df3 = df.cumprod()
df4 = df.cummax()
df5 = df.cummin()
print('df\n', df); print('===========')
print('df1\n', df1); print('===========')
print('df2\n', df2); print('===========')
print('df3\n', df3); print('===========')
print('df4\n', df4); print('===========')
print('df5\n', df5)
执行结果：
df
c1 c2
t1 1 10
t2 -2 20
t3 3 -30
t4 4 -40
t5 -5 50
t6 6 -60
===========
df1
c1 c2
t1 1 10
t2 -1 30
t3 2 0
t4 6 -40
t5 1 10
t6 7 -50
===========
df2
c1 c2
t1 1 11
t2 -2 18
t3 3 -27
t4 4 -36
t5 -5 45
t6 6 -54
===========
df3
c1 c2
t1 1 10
t2 -2 200
t3 -6 -6000
t4 -24 240000
t5 120 12000000
t6 720 -720000000
===========
df4
c1 c2
t1 1 10
t2 1 20
t3 3 20
t4 4 20
t5 4 50
t6 6 50
===========
df5
c1 c2
t1 1 10
t2 -2 10
t3 -2 -30
t4 -2 -40
t5 -5 -40
t6 -5 -60
⑦ df.corr() 相关系数矩阵
语法：df.corr()
返回df每一列的相关系数矩阵（DataFrame格式）
注意：也可以直接使用Series的corr()方法计算两个Series的相关系数，其用法为s1.corr(s2)
# 计算上证指数、深圳成指、沪深300指数的相关系数矩阵
import numpy as np
import pandas as pd
import tushare as ts
df_close = pd.DataFrame({
'sh':ts.get_k_data('sh', start='2019-01-01',end='2019-06-30')['close'],
'sz':ts.get_k_data('sz', start='2019-01-01',end='2019-06-30')['close'],
'hs300':ts.get_k_data('hs300', start='2019-01-01',end='2019-06-30')['close'],
})
df_return = df_close.pct_change().fillna(0)
df_corr = df_return.corr()
print(df_return.head()); print('===========')
print(df_corr); print(type(df_corr))
执行结果：
sh sz hs300
0 0.000000 0.000000 0.000000
1 -0.000377 -0.008369 -0.001583
2 0.020496 0.027562 0.023957
3 0.007245 0.015836 0.006071
4 -0.002617 -0.001155 -0.002161
===========
sh sz hs300
sh 1.000000 0.953529 0.976994
sz 0.953529 1.000000 0.941665
hs300 0.976994 0.941665 1.000000
<class 'pandas.core.frame.DataFrame'>
⑧ df.describe()
语法：df.describe(percentiles=None)
按列统计给定的DataFrame中各项描述性统计信息（包括count()、mean()、std()、min()、50%、max()和自定义的百分位数），返回一个DataFrame
参数percentiles：自定义的百分比列表，是一个由float组成的list。默认值为None，此时默认的自定义百分比是25%、75%。
注意：此方法无axis参数，无法按行统计
import numpy as np
import pandas as pd
arr = np.array([[np.nan,2],[3,4],[5,6]])
df = pd.DataFrame(arr,columns=['c1','c2'],index=['t1','t2','t3'])
print(df); print('===========')
print(df.describe(),'\n',type(df.describe())); print('===========')
print(df.describe(percentiles=[0.05,0.95]),'\n',type(df.describe(percentiles=[0.05,0.95])))
执行结果：
c1 c2
t1 NaN 2.0
t2 3.0 4.0
t3 5.0 6.0
===========
c1 c2
count 2.000000 3.0
mean 4.000000 4.0
std 1.414214 2.0
min 3.000000 2.0
25% 3.500000 3.0
50% 4.000000 4.0
75% 4.500000 5.0
max 5.000000 6.0
<class 'pandas.core.frame.DataFrame'>
===========
c1 c2
count 2.000000 3.0
mean 4.000000 4.0
std 1.414214 2.0
min 3.000000 2.0
5% 3.100000 2.2
50% 4.000000 4.0
95% 4.900000 5.8
max 5.000000 6.0
<class 'pandas.core.frame.DataFrame'>
⑨ df.resample()：重采样
见本章“14. Pandas中的时间相关格式及方法-（9）df.resample()-低频调整为高频（升采样）：通过线性插值实现”
此外，关于DataFrame填充空值的插值法df.interpolate()，见本章“9. DataFrame的空值（NaN）处理 - （5）df.interpolate()”
⑩ df.rolling()：滑动时间窗
见本章“14. Pandas中的时间相关格式及方法 -（10）df.rolling()：滑动时间窗”
（4）将DataFrame存储为本地文件
包括两类方法：
- df.to_xxx()系列方法
- 基于HDF5的存储方法
详见“AQF笔记-第2部分-第7章-金融数据源处理实现-二、金融数据的存储”
（5）其他重要方法
① df.apply()
语法：df.apply(func, axis=0)
将df逐列（或逐行）以Series的形式传递给func作为其参数并执行func()，并将每次func()的返回值组成一个Series，作为df.apply()整体的返回值。
参数：
- func：已定义的函数名，也可以是一个匿名函数
- axis：默认值为0，逐列传递；axis=1时，逐行传递
此外，对于DataFrame分组聚合时建立的分组对象group_obj，也有类似的apply()方法（一个不同之处在于group_obj.apply(func)没有axis参数），其原理及应用详见本章“11. DataFrame的分组、聚合 - （3）分组对象group_obj的应用 - ⑤ 使用group_obj.apply()”
import numpy as np
import pandas as pd
# 从CSV文件读取数据，进行处理后，保留前5行的'code','name','roe'三列
data = pd.read_csv('2019Q1.csv')
data = data.sort_values('code').reset_index()
data = data[['code','name','roe']].head(5)
print(data); print('===========')
# 按ROE对股票进行分类的函数
def map_func(x):
print('----map_func内部开始----')
print(x)
print(type(x))
print('----map_func内部结束----')
if x['roe'] > 4:
return '高成长'
elif x['roe'] >= 0:
return '低成长'
elif x['roe'] < 0:
return '亏损'
# 执行data.apply()，axis=1代表按行取Series传给map_func()
result = data.apply(map_func, axis=1)
print('===========')
print(result)
print(type(result))
print('===========')
# 根据 ROE 数据计算“成长性”，并将此列添加到data
data['成长性'] = result # 相当于data['成长性'] = data.apply(map_func, axis=1)
print(data)
执行结果：
code name roe
0 1 平安银行 2.96
1 2 万科A 0.71
2 4 国农科技 4.66
3 5 世纪星源 -1.20
4 6 深振业A 1.75
===========
----map_func内部开始----
code 1
name 平安银行
roe 2.96
Name: 0, dtype: object
<class 'pandas.core.series.Series'>
----map_func内部结束----
----map_func内部开始----
code 2
name 万科A
roe 0.71
Name: 1, dtype: object
<class 'pandas.core.series.Series'>
----map_func内部结束----
----map_func内部开始----
code 4
name 国农科技
roe 4.66
Name: 2, dtype: object
<class 'pandas.core.series.Series'>
----map_func内部结束----
----map_func内部开始----
code 5
name 世纪星源
roe -1.2
Name: 3, dtype: object
<class 'pandas.core.series.Series'>
----map_func内部结束----
----map_func内部开始----
code 6
name 深振业A
roe 1.75
Name: 4, dtype: object
<class 'pandas.core.series.Series'>
----map_func内部结束----
===========
0 低成长
1 低成长
2 高成长
3 亏损
4 低成长
dtype: object
<class 'pandas.core.series.Series'>
===========
code name roe 成长性
0 1 平安银行 2.96 低成长
1 2 万科A 0.71 低成长
2 4 国农科技 4.66 高成长
3 5 世纪星源 -1.20 亏损
4 6 深振业A 1.75 低成长
② df.applymap()
语法：df.applymap(func)
将df中的每个元素分别传递给func作为其参数并执行func()，并将每次func()的返回值组成一个结构相同的新的DataFrame，作为df.applymap()整体的返回值。
参数：func：已定义的函数名，也可以是一个匿名函数
import numpy as np
import pandas as pd
df1 = pd.DataFrame([[10,20],[30,40]],columns=['c1','c2'],index=['t1','t2'])
df2 = df1.applymap(lambda x:x+1)
print(df1); print('===========')
print(df2)
执行结果：
c1 c2
t1 10 20
t2 30 40
===========
c1 c2
t1 11 21
t2 31 41
关于apply()、applymap()和map()的总结：
| apply() | applymap() | map() | |
|---|---|---|---|
| Python内置函数 | NA | NA | 遍历每一个元素 |
| Series方法 | 遍历每一个元素 | NA | 遍历每一个元素 |
| DataFrame方法 | 遍历行或列 | 遍历每一个元素 | NA |
③ df.iterrows()
语法：df.iterrows()
返回一个生成器（generator），该生成器使用df逐行生成一个元组，其中元组第0项是df的行索引，元组第1项是该行数据组成的Series（df的值也是Series的值，df的列索引则是Series的索引）。上述索引中，有标签索引的优先使用标签索引，否则使用位置索引。通常使用两个变量以拆包的方式分别接收两个返回值。
df.iterrows() 通常用于循环遍历df的每一行数据。
import numpy as np
import pandas as pd
df = pd.DataFrame([[10,20,30],[40,50,60],[70,80,90]],columns=['c1','c2','c3'],index=['t1','t2','t3'])
print(df); print('===========')
print(df.iterrows()); print('===========')
for i,j in df.iterrows():
print(i); print('-----------')
print(type(i)); print('-----------')
print(j); print('-----------')
print(type(j)); print('===========')
执行结果：
c1 c2 c3
t1 10 20 30
t2 40 50 60
t3 70 80 90
===========
<generator object DataFrame.iterrows at 0x000000001431ECA8>
===========
t1
-----------
<class 'str'>
-----------
c1 10
c2 20
c3 30
Name: t1, dtype: int64
-----------
<class 'pandas.core.series.Series'>
===========
t2
-----------
<class 'str'>
-----------
c1 40
c2 50
c3 60
Name: t2, dtype: int64
-----------
<class 'pandas.core.series.Series'>
===========
t3
-----------
<class 'str'>
-----------
c1 70
c2 80
c3 90
Name: t3, dtype: int64
-----------
<class 'pandas.core.series.Series'>
===========
④ df.all()
语法：df.all(axis=0)
返回一个布尔值组成的Series
参数axis：
- 默认值为0，按列计算，Series的索引为df的列索引，当df中该列所有值均为True时，Series中对应项为True，否则为False
- 若axis=1，按行计算，Series的索引为df的行索引，当df中该行所有值均为True时，Series中对应项为True，否则为False
import numpy as np
import pandas as pd
a = pd.DataFrame([[0,0],[1,1]],columns=['c1','c2'],index=['t1','t2'])
b = pd.DataFrame([[1,1],[1,1]],columns=['c1','c2'],index=['t1','t2'])
print(a); print('-----------')
print(a.all()); print('-----------')
print(a.all(axis=1)); print('===========')
print(b); print('-----------')
print(b.all()); print('-----------')
print(b.all(axis=1))
执行结果：
c1 c2
t1 0 0
t2 1 1
-----------
c1 False
c2 False
dtype: bool
-----------
t1 False
t2 True
dtype: bool
===========
c1 c2
t1 1 1
t2 1 1
-----------
c1 True
c2 True
dtype: bool
-----------
t1 True
t2 True
dtype: bool
⑤ df.any()
语法：df.any(axis=0)
返回一个布尔值组成的Series
参数axis：
- 默认值为0，按列计算，Series的索引为df的列索引，当df中该列任意一个值为True时，Series中对应项为True，否则为False
- 若axis=1，按行计算，Series的索引为df的行索引，当df中该行任意一个值为True时，Series中对应项为True，否则为False
import numpy as np
import pandas as pd
a = pd.DataFrame([[0,0],[1,1]],columns=['c1','c2'],index=['t1','t2'])
b = pd.DataFrame([[0,0],[0,0]],columns=['c1','c2'],index=['t1','t2'])
print(a); print('-----------')
print(a.any()); print('-----------')
print(a.any(axis=1)); print('===========')
print(b); print('-----------')
print(b.any()); print('-----------')
print(b.any(axis=1))
执行结果：
c1 c2
t1 0 0
t2 1 1
-----------
c1 True
c2 True
dtype: bool
-----------
t1 False
t2 True
dtype: bool
===========
c1 c2
t1 0 0
t2 0 0
-----------
c1 False
c2 False
dtype: bool
-----------
t1 False
t2 False
dtype: bool
⑥ df.__len__()和len(df)
返回df的长度（int类型），它等于df的行数，即df.shape()返回的元组的第0项
⑦ df.head()
语法：df.head(n=5)
获取df的前n行，n的默认值为5，返回DataFrame类型。示例代码见“6.DataFrame的数据选择 - （5）使用df的属性和方法进行数据选择”
该方法主要用于快速预览一个行数较多的DataFrame
⑧ df.tail()
语法：df.tail(n=5)
获取df的后n行，n的默认值为5，返回DataFrame类型。示例代码见“6.DataFrame的数据选择 - （5）使用df的属性和方法进行数据选择”
该方法主要用于快速预览一个行数较多的DataFrame
⑨ df.info()
自动在屏幕输出df的一些基本信息
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,2],[3,4]], columns=['c1','c2'], index=['t1','t2'])
df.info()
执行结果：
<class 'pandas.core.frame.DataFrame'>
Index: 2 entries, t1 to t2
Data columns (total 2 columns):
c1 2 non-null int64
c2 2 non-null int64
dtypes: int64(2)
memory usage: 48.0+ bytes
⑩ df.duplicated()
语法：df.duplicated(subset=None, keep='first')
判断df中的每一行的值是否重复，返回一个bool组成的Series
参数：
- subset：子集，默认为None，此时两行的所有列的值都相等，才认为这两行重复；当
subset='列标签'或subset=['列标签','列标签',...]时，只要指定的列的值相等，就认为这两行重复 - keep：重复时的标记方式，默认为'first'
- 'first'：在重复的行中，除了第一行标记为False，其他行都标记为True
- 'last'：在重复的行中，除了最后一行标记为False，其他行都标记为True
- False：在重复的行中，所有行均标记为True
import numpy as np
import pandas as pd
df = pd.DataFrame([[1,3],[2,3],[2,3],[1,4],[2,4]])
df.columns = ['c1','c2']
df.index = ['t1','t2','t3','t4','t5']
print(df)
print('---\n',df.duplicated()) # 所有列值都相等视为重复
print('---\n',df.duplicated(subset=['c1'])) # 'c1'列值相等视为重复
print('---\n',df.duplicated(subset=['c2'])) # 'c1'列值相等视为重复
print('---\n',df.duplicated(subset=['c1','c2'])) # 'c1','c2'列值都相等视为重复
执行结果：
c1 c2
t1 1 3
t2 2 3
t3 2 3
t4 1 4
t5 2 4
---
t1 False
t2 False
t3 True
t4 False
t5 False
dtype: bool
---
t1 False
t2 False
t3 True
t4 True
t5 True
dtype: bool
---
t1 False
t2 True
t3 True
t4 False
t5 True
dtype: bool
---
t1 False
t2 False
t3 True
t4 False
t5 False
dtype: bool
⑾ df.rank()
语法：
df.rank(axis=0,method='average',numeric_only=None,na_option='keep',ascending=True,pct=False)
返回一个形状与df相同的DataFrame，里面的数据是其在本列（或本行）所有数据中的排名
参数：
- axis：默认值为0，按列数据计算排名；axis=1时，按行数据计算排名
- method：存在并列时排名的计算方法，默认值为'average'，取值可以为'average'，'first'，'min'， 'max'，'dense'。假设参与升序排名的数据为100、150、150、200：
- average：平均排名，当存在并列时，取这些并列项的顺序排名的平均值（1、2.5、2.5、4）
- first：顺序排名，当存在并列时，谁在DataFrame中的顺序靠前，谁的顺序排名也靠前（1、2、3、4），注意method='first'时不支持非数字类型的排名
- min：最小排名，当存在并列时，取这些并列项的顺序排名的最小值（1、2、2、4）
- max：最大排名，当存在并列时，取这些并列项的顺序排名的最大值（1、3、3、4）
- dense：密集排名，后一项的排名总是与前一项相同或加一，不跳跃（1、2、2、3）
- numeric_only：bool，是否仅仅计算数字类型的columns
- na_option：NaN值是否参与排序及如何排序，默认值'keep'，取值可以为'keep'、'top'、'bottom'：
- 'keep'：NaN的排名还是NaN
- 'top'：把NaN放在排名首位
- 'bottom'：把NaN放在排名末位
- ascending：bool，是否升序，默认值True
- pct：bool，是否以百分比方式显示排名，默认值False
注意：df.rank()只能实现每个字段分别排名，无法实现多字段联合排名，后者的功能需要通过df.groupby(['排序字段1','排序字段2',...]).ngroup()实现
import numpy as np
import pandas as pd
df = pd.DataFrame({'animal': ['cat', 'penguin', 'dog','spider', 'snake'],
'legs': [4, 2, 4, 8, np.nan]})
print("df\n",df,'\n----')
print("df.rank(method='average')\n",df.rank(method='average'),'\n----')
print("df.legs.rank(method='first')\n",df.legs.rank(method='first'),'\n----')
print("df.rank(method='min')\n",df.rank(method='min'),'\n----')
print("df.rank(method='max')\n",df.rank(method='max'),'\n----')
print("df.rank(method='dense')\n",df.rank(method='dense'),'\n====')
print("df.rank(method='min',na_option='top')\n",df.rank(method='min',na_option='top'),'\n----')
print("df.rank(method='min',na_option='bottom')\n",df.rank(method='min',na_option='bottom'),'\n====')
print("df.rank(method='min',pct=True)\n",df.rank(method='min',pct=True))
执行结果：
df
animal legs
0 cat 4.0
1 penguin 2.0
2 dog 4.0
3 spider 8.0
4 snake NaN
----
df.rank(method='average')
animal legs
0 1.0 2.5
1 3.0 1.0
2 2.0 2.5
3 5.0 4.0
4 4.0 NaN
----
df.legs.rank(method='first')
0 2.0
1 1.0
2 3.0
3 4.0
4 NaN
Name: legs, dtype: float64
----
df.rank(method='min')
animal legs
0 1.0 2.0
1 3.0 1.0
2 2.0 2.0
3 5.0 4.0
4 4.0 NaN
----
df.rank(method='max')
animal legs
0 1.0 3.0
1 3.0 1.0
2 2.0 3.0
3 5.0 4.0
4 4.0 NaN
----
df.rank(method='dense')
animal legs
0 1.0 2.0
1 3.0 1.0
2 2.0 2.0
3 5.0 3.0
4 4.0 NaN
====
df.rank(method='min',na_option='top')
animal legs
0 1.0 3.0
1 3.0 2.0
2 2.0 3.0
3 5.0 5.0
4 4.0 1.0
----
df.rank(method='min',na_option='bottom')
animal legs
0 1.0 2.0
1 3.0 1.0
2 2.0 2.0
3 5.0 4.0
4 4.0 5.0
====
df.rank(method='min',pct=True)
animal legs
0 0.2 0.50
1 0.6 0.25
2 0.4 0.50
3 1.0 1.00
4 0.8 NaN
11. DataFrame的分组、聚合
（1）分组对象group_obj的创建
DataFrame的分组、聚合都是基于分组对象group_obj实现的（它是pandas.core.groupby.generic. DataFrameGroupBy类的一个实例化对象），因此首先应创建分组对象group_obj，语法为：
- 按照一列进行分组时：
group_obj = df.groupby('列标签') - 按照多列联合分组时：
group_obj = df.groupby(['列标签','列标签',...])
（2）分组对象group_obj的构成
假设按照创建分组对象group_obj时定义的分组规则，一共可以分成n组，则group_obj就是一个由n个元组组成的可迭代对象，其中每个元组的第0项是一种分组下的列标签（或元组形式的多个列标签的组合），每个元组第1项是该分组下对应的DataFrame。
（3）分组对象group_obj的应用
① 使用group_obj的指定方法查看df的一项统计信息
- group_obj.size()：每个分组的记录数（含带空值的记录）（Series类型）
- group_obj.max()：每个分组的最大值（DataFrame类型）
- group_obj.min()：每个分组的最小值（DataFrame类型）
- group_obj.sum()：每个分组的求和（DataFrame类型）
- group_obj.mean()：每个分组的平均值（DataFrame类型）
- group_obj.std()：每个分组的标准差（DataFrame类型）
- group_obj.count()：每个分组的非空记录数（DataFrame类型）
- group_obj.cumsum()：逐行的累加和（与原DataFrame行数相等的DataFrame）
- group_obj.cumprod()：逐行的累乘积（与原DataFrame行数相等的DataFrame）
- group_obj.cumcount()：从0开始的逐行的累加计数（与原DataFrame行数相等的Series）
② 使用group_obj.describe()查看df的全部统计信息
- group_obj.describe()：横向查看，因表格过长，不推荐（DataFrame类型）
- group_obj.describe().T：纵向查看，推荐（DataFrame类型）
③ 使用group_obj.agg()查看自定义项目的统计信息
-
group_obj.agg([np.mean, np.std])：查看所有字段的均值和标准差（DataFrame类型） -
group_obj.agg({'c1':np.mean, 'c2':np.std})：查看'c1'字段的均值和'c2'字段的标准差（DataFrame类型）
④ 使用group_obj.get_group()获取指定分组的数据
- 按照一列进行分组时获取数据：
group_obj.get_group('分组字段的某个值') - 按照多列联合分组时获取数据：
group_obj.get_group(('分组字段1的某个值','分组字段2的某个值',...))
⑤ 使用group_obj.ngroup()实现多字段联合排名
语法：group_obj.ngroup(ascending=True)
返回一个Series。根据创建group_obj时的几个分组字段，比较每个字段的值，当第一个字段的值相等时比较第二个字段，当第二个字段相等时比较第三个字段……若所有分组字段的值都相等，则两条记录的排名也相同（注意：排名是从0开始的）
import numpy as np
import pandas as pd
# 创建DataFrame
data = [('a', 70, 5),
('b', 80, 4),
('c', 70, 4),
('d', 70, 5),
('e', 80, 5),
('f', 75, 4)]
df = pd.DataFrame(data, columns=['name', 'score', 'homework'])
df = df.sort_values(['score', 'homework'], ascending=False)
print(df, '\n----------')
s = df.groupby(['score', 'homework']).ngroup(ascending=False)
print(s, '\n----------\n', type(s), '\n----------')
df['ranking'] = s + 1
print(df)
执行结果：
name score homework
4 e 80 5
1 b 80 4
5 f 75 4
0 a 70 5
3 d 70 5
2 c 70 4
----------
4 0
1 1
5 2
0 3
3 3
2 4
dtype: int64
----------
<class 'pandas.core.series.Series'>
----------
name score homework ranking
4 e 80 5 1
1 b 80 4 2
5 f 75 4 3
0 a 70 5 4
3 d 70 5 4
2 c 70 4 5
⑥ 使用group_obj.apply()实现自定义功能
语法：group_obj.apply(func)
参数func：已定义的函数名，也可以是一个匿名函数
将构成group_obj的每个元组中的DataFrame分别传递给func作为其参数并执行func()，然后将每次func()的返回值纵向拼接成一个DataFrame或Series，并为其在列标签的最外层添加分组列组成的列标签索引（联合分组时则在列标签的最外层添加多层列标签索引），然后将其作为group_obj.apply()整体的返回值。group_obj.apply()的应用见下面的例3。
此外，对于DataFrame对象，也有类似的apply()方法（一个不同之处在于df.apply(func,axis=0)有axis参数），其原理及应用详见本章“10. DataFrame对象的方法和Pandas模块的方法 -（5）其他方法 - ① df.apply()”
# 例1：本例仅用于研究分组对象group_obj的构成（group_obj的应用见例2）
import numpy as np
import pandas as pd
# 创建数据集
np.random.seed(0)
period = pd.date_range('2019-9-22', periods=1000, freq='D')
df = pd.DataFrame(np.random.randn(1000, 2), columns=['c1','c2'], index = period)
df['g1'] = np.random.choice(['M', 'N'], 1000)
df['g2'] = np.random.choice(['X', 'Y'], 1000)
for i in period: # 随机产生空值
if np.random.random() < 0.05: df.loc[i,'c1'] = np.nan
if np.random.random() < 0.05: df.loc[i,'c2'] = np.nan
print('df.head()\n',df.head()); print('===========')
# 创建分组对象（由于这里是研究分组对象group_obj的构成，所以仅查看按照两列联合分组的结果）
# group_obj = df.groupby('g1') # 按照一列进行分组
group_obj = df.groupby(['g1','g2']) # 按照两列联合分组
for i in group_obj:
print('开始一次group_obj的迭代\n',type(i)); print('-----------')
for j in i:
print(j); print('-----------')
print(type(j)); print('-----------')
执行结果：
df.head()
c1 c2 g1 g2
2019-09-22 NaN 0.400157 N X
2019-09-23 0.978738 2.240893 N Y
2019-09-24 1.867558 -0.977278 M X
2019-09-25 0.950088 -0.151357 N X
2019-09-26 -0.103219 0.410599 M Y
===========
开始一次group_obj的迭代
<class 'tuple'>
-----------
('M', 'X')
-----------
<class 'tuple'>
-----------
c1 c2 g1 g2
2019-09-24 1.867558 -0.977278 M X
... ... ... .. ..
2022-06-17 -1.141901 -1.310970 M X
[260 rows x 4 columns]
-----------
<class 'pandas.core.frame.DataFrame'>
-----------
开始一次group_obj的迭代
<class 'tuple'>
-----------
('M', 'Y')
-----------
<class 'tuple'>
-----------
c1 c2 g1 g2
2019-09-26 -0.103219 0.410599 M Y
... ... ... .. ..
2022-06-15 0.197828 0.097751 M Y
[245 rows x 4 columns]
-----------
<class 'pandas.core.frame.DataFrame'>
-----------
开始一次group_obj的迭代
<class 'tuple'>
-----------
('N', 'X')
-----------
<class 'tuple'>
-----------
c1 c2 g1 g2
2019-09-22 NaN 0.400157 N X
... ... ... .. ..
2022-06-14 1.315138 -0.323457 N X
[256 rows x 4 columns]
-----------
<class 'pandas.core.frame.DataFrame'>
-----------
开始一次group_obj的迭代
<class 'tuple'>
-----------
('N', 'Y')
-----------
<class 'tuple'>
-----------
c1 c2 g1 g2
2019-09-23 0.978738 2.240893 N Y
... ... ... .. ..
2022-06-16 1.401523 NaN N Y
[239 rows x 4 columns]
-----------
<class 'pandas.core.frame.DataFrame'>
# 例2：group_obj的应用（group_obj.apply()见例3）
import numpy as np
import pandas as pd
# 创建数据集
np.random.seed(0)
period = pd.date_range('2019-9-22', periods=1000, freq='D')
df = pd.DataFrame(np.random.randn(1000, 2), columns=['c1','c2'], index = period)
df['g1'] = np.random.choice(['M', 'N'], 1000)
df['g2'] = np.random.choice(['X', 'Y'], 1000)
for i in period: # 随机产生空值
if np.random.random() < 0.05: df.loc[i,'c1'] = np.nan
if np.random.random() < 0.05: df.loc[i,'c2'] = np.nan
print('df.head()\n',df.head()); print('===========')
# 创建分组对象
group_obj = df.groupby('g1') # 按照一列进行分组
# group_obj = df.groupby(['g1','g2']) # 按照两列联合分组
print('group_obj\n',group_obj); print('===========')
print('type(group_obj)\n',type(group_obj)); print('===========')
# 使用分组对象的指定方法查看一项统计信息
print('group_obj.size()\n',group_obj.size(),'\n',type(group_obj.size())); print('===========')
print('group_obj.max()\n',group_obj.max(),'\n',type(group_obj.max())); print('===========')
print('group_obj.min()\n',group_obj.min(),'\n',type(group_obj.min())); print('===========')
print('group_obj.sum()\n',group_obj.sum(),'\n',type(group_obj.sum())); print('===========')
print('group_obj.mean()\n',group_obj.mean(),'\n',type(group_obj.mean())); print('===========')
print('group_obj.std()\n',group_obj.std(),'\n',type(group_obj.std())); print('===========')
print('group_obj.count()\n',group_obj.count(),'\n',type(group_obj.count())); print('===========')
# 使用分组对象的describe()方法查看全部统计信息
print('group_obj.describe()\n',group_obj.describe(),'\n',type(group_obj.describe())); print('===========')
print('group_obj.describe().T\n',group_obj.describe().T,'\n',type(group_obj.describe().T)); print('===========')
# 使用分组对象的agg()方法查看自定义项目的统计信息
print('group_obj.agg([np.mean, np.std])\n',group_obj.agg([np.mean, np.std]),'\n',type(group_obj.agg([np.mean, np.std]))); print('===========')
print("group_obj.agg({'c1':np.mean, 'c2':np.std})\n",group_obj.agg({'c1':np.mean, 'c2':np.std}),'\n',type(group_obj.agg({'c1':np.mean, 'c2':np.std}))); print('===========')
# 使用分组对象的get_group()方法获取指定分组的数据
# 按照一列进行分组时获取数据
print("group_obj.get_group('M').head()\n",group_obj.get_group('M').head())
# 按照两列联合分组时获取数据
# print("group_obj.get_group(('M','X')).head()\n",group_obj.get_group(('M','X')).head())
# 例2的执行结果(按照一列进行分组)：
df.head()
c1 c2 g1 g2
2019-09-22 NaN 0.400157 N X
2019-09-23 0.978738 2.240893 N Y
2019-09-24 1.867558 -0.977278 M X
2019-09-25 0.950088 -0.151357 N X
2019-09-26 -0.103219 0.410599 M Y
===========
group_obj
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x0000000003DEB518>
===========
type(group_obj)
<class 'pandas.core.groupby.generic.DataFrameGroupBy'>
===========
group_obj.size()
g1
M 505
N 495
dtype: int64
<class 'pandas.core.series.Series'>
===========
group_obj.max()
c1 c2 g2
g1
M 2.680571 2.642936 Y
N 3.170975 2.759355 Y
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.min()
c1 c2 g2
g1
M -2.802203 -2.772593 X
N -2.994613 -3.046143 X
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.sum()
c1 c2
g1
M -21.519519 -23.540760
N 3.243500 1.208014
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.mean()
c1 c2
g1
M -0.046080 -0.048338
N 0.006901 0.002549
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.std()
c1 c2
g1
M 0.989397 0.982953
N 0.963094 0.980751
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.count()
c1 c2 g2
g1
M 467 487 505
N 470 474 495
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.describe()
c1 ... c2
count mean std min ... 25% 50% 75% max
g1 ...
M 467.0 -0.046080 0.989397 -2.802203 ... -0.735622 -0.065488 0.549966 2.642936
N 470.0 0.006901 0.963094 -2.994613 ... -0.600193 -0.003481 0.656109 2.759355
[2 rows x 16 columns]
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.describe().T
g1 M N
c1 count 467.000000 470.000000
mean -0.046080 0.006901
std 0.989397 0.963094
min -2.802203 -2.994613
25% -0.726487 -0.669359
50% -0.056133 0.038123
75% 0.603422 0.669524
max 2.680571 3.170975
c2 count 487.000000 474.000000
mean -0.048338 0.002549
std 0.982953 0.980751
min -2.772593 -3.046143
25% -0.735622 -0.600193
50% -0.065488 -0.003481
75% 0.549966 0.656109
max 2.642936 2.759355
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.agg([np.mean, np.std])
c1 c2
mean std mean std
g1
M -0.046080 0.989397 -0.048338 0.982953
N 0.006901 0.963094 0.002549 0.980751
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.agg({'c1':np.mean, 'c2':np.std})
c1 c2
g1
M -0.046080 0.982953
N 0.006901 0.980751
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.get_group('M').head()
c1 c2 g1 g2
2019-09-24 1.867558 -0.977278 M X
2019-09-26 -0.103219 0.410599 M Y
2019-09-29 0.443863 0.333674 M Y
2019-09-30 1.494079 -0.205158 M X
2019-10-05 0.045759 -0.187184 M X
# 例2的执行结果(按照两列联合分组)：
df.head()
c1 c2 g1 g2
2019-09-22 NaN 0.400157 N X
2019-09-23 0.978738 2.240893 N Y
2019-09-24 1.867558 -0.977278 M X
2019-09-25 0.950088 -0.151357 N X
2019-09-26 -0.103219 0.410599 M Y
===========
group_obj
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x0000000003F5B518>
===========
type(group_obj)
<class 'pandas.core.groupby.generic.DataFrameGroupBy'>
===========
group_obj.size()
g1 g2
M X 260
Y 245
N X 256
Y 239
dtype: int64
<class 'pandas.core.series.Series'>
===========
group_obj.max()
c1 c2
g1 g2
M X 2.320800 2.642936
Y 2.680571 2.380745
N X 3.170975 2.412454
Y 2.497200 2.759355
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.min()
c1 c2
g1 g2
M X -2.802203 -2.534554
Y -2.437564 -2.772593
N X -2.582797 -2.739677
Y -2.994613 -3.046143
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.sum()
c1 c2
g1 g2
M X -18.444141 -21.132778
Y -3.075378 -2.407982
N X 20.090225 -1.593149
Y -16.846726 2.801164
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.mean()
c1 c2
g1 g2
M X -0.077496 -0.083860
Y -0.013430 -0.010247
N X 0.084413 -0.006611
Y -0.072615 0.012022
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.std()
c1 c2
g1 g2
M X 1.002794 0.976511
Y 0.976399 0.990480
N X 0.985893 0.900264
Y 0.934578 1.059461
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.count()
c1 c2
g1 g2
M X 238 252
Y 229 235
N X 238 241
Y 232 233
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.describe()
c1 ... c2
count mean std ... 50% 75% max
g1 g2 ...
M X 238.0 -0.077496 1.002794 ... -0.122370 0.553665 2.642936
Y 229.0 -0.013430 0.976399 ... 0.024612 0.548398 2.380745
N X 238.0 0.084413 0.985893 ... 0.001248 0.547481 2.412454
Y 232.0 -0.072615 0.934578 ... -0.008210 0.823504 2.759355
[4 rows x 16 columns]
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.describe().T
g1 M N
g2 X Y X Y
c1 count 238.000000 229.000000 238.000000 232.000000
mean -0.077496 -0.013430 0.084413 -0.072615
std 1.002794 0.976399 0.985893 0.934578
min -2.802203 -2.437564 -2.582797 -2.994613
25% -0.799725 -0.652409 -0.531745 -0.708426
50% -0.031588 -0.061743 0.039490 0.018710
75% 0.601873 0.604137 0.721432 0.591636
max 2.320800 2.680571 3.170975 2.497200
c2 count 252.000000 235.000000 241.000000 233.000000
mean -0.083860 -0.010247 -0.006611 0.012022
std 0.976511 0.990480 0.900264 1.059461
min -2.534554 -2.772593 -2.739677 -3.046143
25% -0.698973 -0.740036 -0.575788 -0.680178
50% -0.122370 0.024612 0.001248 -0.008210
75% 0.553665 0.548398 0.547481 0.823504
max 2.642936 2.380745 2.412454 2.759355
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.agg([np.mean, np.std])
c1 c2
mean std mean std
g1 g2
M X -0.077496 1.002794 -0.083860 0.976511
Y -0.013430 0.976399 -0.010247 0.990480
N X 0.084413 0.985893 -0.006611 0.900264
Y -0.072615 0.934578 0.012022 1.059461
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.agg({'c1':np.mean, 'c2':np.std})
c1 c2
g1 g2
M X -0.077496 0.976511
Y -0.013430 0.990480
N X 0.084413 0.900264
Y -0.072615 1.059461
<class 'pandas.core.frame.DataFrame'>
===========
group_obj.get_group(('M','X')).head()
c1 c2 g1 g2
2019-09-24 1.867558 -0.977278 M X
2019-09-30 1.494079 -0.205158 M X
2019-10-05 0.045759 -0.187184 M X
2019-10-12 -1.048553 -1.420018 M X
2019-10-13 NaN 1.950775 M X
# 例3：group_obj.apply()的原理及应用
import numpy as np
import pandas as pd
# 创建数据集
np.random.seed(0)
period = pd.date_range('2019-9-22', periods=1000, freq='D')
df = pd.DataFrame(np.random.randn(1000, 2), columns=['c1','c2'], index = period)
df['g1'] = np.random.choice(['M', 'N'], 1000)
df['g2'] = np.random.choice(['X', 'Y'], 1000)
for i in period: # 随机产生空值
if np.random.random() < 0.05: df.loc[i,'c1'] = np.nan
if np.random.random() < 0.05: df.loc[i,'c2'] = np.nan
print('df.head()\n',df.head()); print('===========')
# 仅演示按照两列联合分组的情况
# group_obj = df.groupby('g1') # 按照一列进行分组
group_obj = df.groupby(['g1','g2']) # 按照两列联合分组
def group_func(df):
print('---group_func内部开始---')
print(df)
print(type(df))
print('---group_func内部结束---')
# 将df按照'c1'列升序排列，取前两行结果作为返回值
return df.sort_values(['c1'], ascending=True)[:2]
result = group_obj.apply(group_func)
print('===========')
print(result); print('-----------')
print(type(result)); print('-----------')
print(result.index)
执行结果：
df.head()
c1 c2 g1 g2
2019-09-22 NaN 0.400157 N X
2019-09-23 0.978738 2.240893 N Y
2019-09-24 1.867558 -0.977278 M X
2019-09-25 0.950088 -0.151357 N X
2019-09-26 -0.103219 0.410599 M Y
===========
---group_func内部开始---
c1 c2 g1 g2
2019-09-24 1.867558 -0.977278 M X
... ... ... .. ..
2022-06-17 -1.141901 -1.310970 M X
[260 rows x 4 columns]
<class 'pandas.core.frame.DataFrame'>
---group_func内部结束---
---group_func内部开始---
c1 c2 g1 g2
2019-09-26 -0.103219 0.410599 M Y
... ... ... .. ..
2022-06-15 0.197828 0.097751 M Y
[245 rows x 4 columns]
<class 'pandas.core.frame.DataFrame'>
---group_func内部结束---
---group_func内部开始---
c1 c2 g1 g2
2019-09-22 NaN 0.400157 N X
... ... ... .. ..
2022-06-14 1.315138 -0.323457 N X
[256 rows x 4 columns]
<class 'pandas.core.frame.DataFrame'>
---group_func内部结束---
---group_func内部开始---
c1 c2 g1 g2
2019-09-23 0.978738 2.240893 N Y
... ... ... .. ..
2022-06-16 1.401523 NaN N Y
[239 rows x 4 columns]
<class 'pandas.core.frame.DataFrame'>
---group_func内部结束---
===========
c1 c2 g1 g2
g1 g2
M X 2021-08-31 -2.802203 -1.188424 M X
2020-03-07 -2.659172 0.606320 M X
Y 2022-03-03 -2.437564 1.114925 M Y
2020-05-13 -2.288620 0.251484 M Y
N X 2020-11-20 -2.582797 -1.153950 N X
2020-06-12 -2.369587 0.864052 N X
Y 2021-09-14 -2.994613 0.880938 N Y
2021-06-11 -2.777359 1.151734 N Y
-----------
<class 'pandas.core.frame.DataFrame'>
-----------
MultiIndex([('M', 'X', '2021-08-31'),
('M', 'X', '2020-03-07'),
('M', 'Y', '2022-03-03'),
('M', 'Y', '2020-05-13'),
('N', 'X', '2020-11-20'),
('N', 'X', '2020-06-12'),
('N', 'Y', '2021-09-14'),
('N', 'Y', '2021-06-11')],
names=['g1', 'g2', None])
12. DataFrame的合并
DataFrame的合并可以基于DataFrame定义、concat()、join()、merge()来实现，其中merge()的功能最为强大，使用它也可以实现其他方法的功能
（1）基于DataFrame定义的合并
最原始的合并方式，需要手动逐列定义字典的键（列标签）和值（列数据），行标签则只能采取外连接方式（取并集）
import numpy as np
import pandas as pd
# 定义原始数据
df1 = pd.DataFrame([[1,2],[3,4]], columns=['c2','c1'], index=['t2','t1'])
df2 = pd.DataFrame([[5,6],[7,8]], columns=['c3','c1'], index=['t3','t1'])
# 开始合并
df = pd.DataFrame({'C2': df1['c2'], 'C3': df2['c3']})
print('df1\n',df1); print('===========')
print('df2\n',df2); print('===========')
print('df\n',df)
执行结果：
df1
c2 c1
t2 1 2
t1 3 4
===========
df2
c3 c1
t3 5 6
t1 7 8
===========
df
C2 C3
t1 3.0 7.0
t2 1.0 NaN
t3 NaN 5.0
（2）df.append()
语法：df.append(obj, sort=???, ignore_index=False)
整体与pd.concat()实现的效果类似，纵向拼接，行标签不合并且保留原始顺序，列标签会合并
参数：
- obj：拼接对象，可以是一个DataFrame或Series。当是Series时，须满足下面两个条件之一（即要么拼接的这行自己有名字作为其行标签，要么忽略所有行标签），否则报错：
- 该Series有name属性
- df.append()中的ignore_index参数值为True
- sort：布尔值，拼接后的DataFrame是否按列标签排序。注意：当前版本Pandas默认值为None（根据不同的情况默认True或False），未来版本会取消默认值，因此为保险起见，不管sort为True还是False都要写上，不写会弹出警告（warning）
- ignore_index：拼接后的DataFrame是否忽略所有行标签（即重置为0、1、2……的行位置索引），默认值为False
import numpy as np
import pandas as pd
import warnings; warnings.simplefilter('ignore') # 忽略可能会出现的警告信息；警告并不是错误，可以忽略；可能出现警告的场景包括：df.ix[]、pd.concat()
# 定义原始数据
df1 = pd.DataFrame([[1,2],[3,4]], columns=['c2','c1'], index=['t2','t1'])
df2 = pd.DataFrame([[5,6],[7,8]], columns=['c3','c1'], index=['t3','t1'])
s1 = pd.Series([9,10,11],index=['c2','c4','c3'], name='s1')
s2 = pd.Series([12,13,14],index=['c2','c4','c3'])
# 开始拼接
df3 = df1.append(df2, sort=False)
df4 = df1.append(df2, sort=True)
df5 = df1.append(df2, sort=False, ignore_index=True)
df6 = df1.append(s1, sort=False)
df7 = df1.append(s2, sort=False, ignore_index=True)
print('df1\n',df1); print('===========')
print('df2\n',df2); print('===========')
print('df3\n',df3); print('===========')
print('df4\n',df4); print('===========')
print('df5\n',df5); print('===========')
print('df6\n',df6); print('===========')
print('df7\n',df7)
执行结果：
df1
c2 c1
t2 1 2
t1 3 4
===========
df2
c3 c1
t3 5 6
t1 7 8
===========
df3
c2 c1 c3
t2 1.0 2 NaN
t1 3.0 4 NaN
t3 NaN 6 5.0
t1 NaN 8 7.0
===========
df4
c1 c2 c3
t2 2 1.0 NaN
t1 4 3.0 NaN
t3 6 NaN 5.0
t1 8 NaN 7.0
===========
df5
c2 c1 c3
0 1.0 2 NaN
1 3.0 4 NaN
2 NaN 6 5.0
3 NaN 8 7.0
===========
df6
c2 c1 c3 c4
t2 1.0 2.0 NaN NaN
t1 3.0 4.0 NaN NaN
s1 9.0 NaN 11.0 10.0
===========
df7
c2 c1 c3 c4
0 1.0 2.0 NaN NaN
1 3.0 4.0 NaN NaN
2 12.0 NaN 14.0 13.0
（3）df.join()
语法：df1.join(df2, how='left', lsuffix='', rsuffix='')
只能实现横向拼接，列标签不允许重名也不能合并（重名时须指定后缀），行标签可以选择左、右、内、外四种连接方式（默认左连接）
参数：
- how：行标签显示方式
- 默认值为'left'，左连接，显示左侧df的所有行标签
- how='right'时，右连接，显示右侧df的所有行标签
- how='inner'时，内连接，显示df1和df2行标签的交集
- how='outer'时，外连接，显示df1和df2行标签的并集
- lsuffix：有重名列时，左侧df该列的标签添加的后缀，默认为空字符串''
- rsuffix：有重名列时，右侧df该列的标签添加的后缀，默认为空字符串''
注意：
- 当有重名列时，lsuffix和rsuffix至少应有一个不为空，否则报错
import numpy as np
import pandas as pd
# 定义原始数据
df1 = pd.DataFrame([[1,2],[3,4]], columns=['c2','c1'], index=['t2','t1'])
df2 = pd.DataFrame([[5,6],[7,8]], columns=['c3','c1'], index=['t3','t1'])
# 开始合并
df3 = df1.join(df2, lsuffix='_l', rsuffix='_r')
df4 = df1.join(df2, how='left', lsuffix='_l', rsuffix='_r')
df5 = df1.join(df2, how='right', lsuffix='_l', rsuffix='_r')
df6 = df1.join(df2, how='inner', lsuffix='_l', rsuffix='_r')
df7 = df1.join(df2, how='outer', lsuffix='_l', rsuffix='_r')
print('df1\n',df1); print('===========')
print('df2\n',df2); print('===========')
print('df3\n',df3); print('===========')
print('df4\n',df4); print('===========')
print('df5\n',df5); print('===========')
print('df6\n',df6); print('===========')
print('df7\n',df7)
执行结果：
df1
c2 c1
t2 1 2
t1 3 4
===========
df2
c3 c1
t3 5 6
t1 7 8
===========
df3
c2 c1_l c3 c1_r
t2 1 2 NaN NaN
t1 3 4 7.0 8.0
===========
df4
c2 c1_l c3 c1_r
t2 1 2 NaN NaN
t1 3 4 7.0 8.0
===========
df5
c2 c1_l c3 c1_r
t3 NaN NaN 5 6
t1 3.0 4.0 7 8
===========
df6
c2 c1_l c3 c1_r
t1 3 4 7 8
===========
df7
c2 c1_l c3 c1_r
t1 3.0 4.0 7.0 8.0
t2 1.0 2.0 NaN NaN
t3 NaN NaN 5.0 6.0
（4）pd.concat()
语法：pd.concat(objs, axis=0, join='outer', ignore_index=False, sort=???, keys=None, names=None)
实现纵向拼接（拼接轴为y轴）或横向拼接（拼接轴为x轴），拼接轴上的标签不合并且保留原始顺序，非拼接轴上的标签会合并
参数：
objs：由若干个DataFrame组成的可迭代对象，如
(df1,df2)、[df1,df2,df3]等axis：默认值为0，纵向拼接，行标签不合并且顺序不变，列标签合并；axis=1时，横向拼接，列标签不合并且顺序不变，行标签合并。
-
join：默认值为'outer'，非拼接轴外连接（取并集）；join='inner'时，非拼接轴内连接（取交集）
注意：join的取值只能是'outer'或'inner'，没有别的
ignore_index：默认值为False，保留拼接轴的标签索引；ignore_index=True时，删除拼接轴的标签索引
sort：当join='outer'时，非拼接轴是否按标签排序；当join='inner'时，sort参数没有用。注意：当前版本Pandas默认值为True，未来版本默认值将改为False，因此为保险起见，只要join='outer'，不管sort为True还是False都要写上，不写会弹出警告（warning）
keys：是一个list，当axis=0时，在y轴最外层添加一个层次化索引，这个list中的每个元素都是该层次化索引的行标签，即该list的长度应该等于objs的长度（因为给objs中的每一个DataFrame都分配了一个最外层层次化索引的行标签）；当axis=1则对x轴执行相似操作。代码示例见
“AQF笔记-第2部分-第7章-金融数据源处理实现-三、金融数据的处理-2.同时获取多只股价信息”names：是一个list，当axis=0时，里面的每个元素都是y轴的每级层次化索引的名字（因为每级层次化索引都是一个Series，相当于批量设置每个Series的name属性）；当axis=1则对x轴执行相似操作。代码示例见
“AQF笔记-第2部分-第7章-金融数据源处理实现-三、金融数据的处理-2.同时获取多只股价信息”
import numpy as np
import pandas as pd
import warnings; warnings.simplefilter('ignore') # 忽略可能会出现的警告信息；警告并不是错误，可以忽略；可能出现警告的场景包括：df.ix[]、pd.concat()
# 定义原始数据
df1 = pd.DataFrame([[1,2],[3,4]], columns=['c2','c1'], index=['t2','t1'])
df2 = pd.DataFrame([[5,6],[7,8]], columns=['c3','c1'], index=['t3','t1'])
# 开始拼接
df3 = pd.concat((df1,df2), sort=True)
df4 = pd.concat((df1,df2), sort=False)
df5 = pd.concat((df1,df2), sort=True, join='inner')
df6 = pd.concat((df1,df2), axis=1, sort=True)
df7 = pd.concat((df1,df2), ignore_index=True, sort=True)
df8 = pd.concat((df1,df2), axis=1, ignore_index=True, sort=True)
print('df1\n',df1); print('===========')
print('df2\n',df2); print('===========')
print('df3\n',df3); print('===========')
print('df4\n',df4); print('===========')
print('df5\n',df5); print('===========')
print('df6\n',df6); print('===========')
print('df7\n',df7); print('===========')
print('df8\n',df8)
执行结果：
df1
c2 c1
t2 1 2
t1 3 4
===========
df2
c3 c1
t3 5 6
t1 7 8
===========
df3
c1 c2 c3
t2 2 1.0 NaN
t1 4 3.0 NaN
t3 6 NaN 5.0
t1 8 NaN 7.0
===========
df4
c2 c1 c3
t2 1.0 2 NaN
t1 3.0 4 NaN
t3 NaN 6 5.0
t1 NaN 8 7.0
===========
df5
c1
t2 2
t1 4
t3 6
t1 8
===========
df6
c2 c1 c3 c1
t1 3.0 4.0 7.0 8.0
t2 1.0 2.0 NaN NaN
t3 NaN NaN 5.0 6.0
===========
df7
c1 c2 c3
0 2 1.0 NaN
1 4 3.0 NaN
2 6 NaN 5.0
3 8 NaN 7.0
===========
df8
0 1 2 3
t1 3.0 4.0 7.0 8.0
t2 1.0 2.0 NaN NaN
t3 NaN NaN 5.0 6.0
（5）pd.merge()
只能实现横向拼接，列标签不会出现重名也不能合并（重名时会自动添加后缀），行标签可以选择内、外、左、右、四种连接方式（默认内连接）。根据主键选取方式的不同，语法分为三种情况（分别对应下方示例代码的例1、例2、例3）：
-
以行标签为主键（行标签相同的合并为一行），保留行标签信息：
pd.merge(df1, df2, how='inner', left_index=True, right_index=True, sort=False, suffixes=('_x', '_y'))注意：此方法与join()实现的效果共同；此外，left_index和right_index的默认值都是False，如果想采用此方法，需要手动传关键字参数
-
以df1和df2的一个同名列为主键（该列值相同的合并为一行），会导致丢失行标签信息：
pd.merge(df1, df2, how='inner', on='主键列标签', sort=False, suffixes=('_x', '_y'))注意：不写on参数时，Pandas会以首个df1和df2都有的同名列为主键，可能会自动匹配到错误的列，因此建议写上on这个参数，以便明确地声明使用哪列作为主键
-
以df1的某一列为主键，以df2的另一列为主键（主键列值相同的合并为一行），会导致丢失行标签信息：
pd.merge(df1, df2, how='inner', left_on='df1的主键列标签', right_on='df2的主键列标签', sort=False, suffixes=('_x','_y'))
公共参数：
- how：行标签显示方式
- 默认值为'inner'，内连接，主键列显示df1和df2主键的交集
- how='outer'时，外连接，主键列显示df1和df2主键的并集
- how='left'时，左连接，主键列为左侧df1的主键列
- how='right'时，右连接，主键列为右侧df2的主键列
- sort：是否对返回结果的主键列排序，默认值为False
- suffixes：非主键列重名时添加的后缀，是一个元组类型数据，元组第一项给df1用，第二项给df2用，默认值为
('_x', '_y')。元组的两项值可以相同，但是不能同时为空
# 例1：以行标签为主键（行标签相同的合并为一行）
import numpy as np
import pandas as pd
# 定义原始数据
df1 = pd.DataFrame([[1,2],[3,4]], columns=['c2','c1'], index=['t2','t1'])
df2 = pd.DataFrame([[5,6],[7,8]], columns=['c3','c1'], index=['t3','t1'])
# 开始合并
df3 = pd.merge(df1,df2,left_index=True,right_index=True)
df4 = pd.merge(df1,df2,how='outer',left_index=True,right_index=True)
df5 = pd.merge(df1,df2,how='outer',left_index=True,right_index=True,sort=True,suffixes=('_df1', '_df2'))
df6 = pd.merge(df1,df2,how='left',left_index=True,right_index=True)
df7 = pd.merge(df1,df2,how='right',left_index=True,right_index=True)
print('df1\n',df1); print('===========')
print('df2\n',df2); print('===========')
print('df3\n',df3); print('===========')
print('df4\n',df4); print('===========')
print('df5\n',df5); print('===========')
print('df6\n',df6); print('===========')
print('df7\n',df7)
执行结果：
df1
c2 c1
t2 1 2
t1 3 4
===========
df2
c3 c1
t3 5 6
t1 7 8
===========
df3
c2 c1_x c3 c1_y
t1 3 4 7 8
===========
df4
c2 c1_x c3 c1_y
t1 3.0 4.0 7.0 8.0
t2 1.0 2.0 NaN NaN
t3 NaN NaN 5.0 6.0
===========
df5
c2 c1_df1 c3 c1_df2
t1 3.0 4.0 7.0 8.0
t2 1.0 2.0 NaN NaN
t3 NaN NaN 5.0 6.0
===========
df6
c2 c1_x c3 c1_y
t2 1 2 NaN NaN
t1 3 4 7.0 8.0
===========
df7
c2 c1_x c3 c1_y
t3 NaN NaN 5 6
t1 3.0 4.0 7 8
# 例2：以df1和df2的同名列'c1'为主键（'c1'列值相同的合并为一行），会导致丢失行标签信息
import numpy as np
import pandas as pd
# 定义原始数据
df1 = pd.DataFrame([[1,'C'],[2,'B']], columns=['c2','c1'], index=['t2','t1'])
df2 = pd.DataFrame([[3,'C'],[4,'A']], columns=['c2','c1'], index=['t2','t1'])
# 开始合并
df3 = pd.merge(df1,df2) # 以首个df1和df2都有的列为主键，因此这里自动匹配到的是'c2'列，不是'c1'列
df4 = pd.merge(df1,df2,how='inner',on='c1')
df5 = pd.merge(df1,df2,how='outer',on='c1')
df6 = pd.merge(df1,df2,how='outer',on='c1',sort=True,suffixes=('_df1', '_df2'))
df7 = pd.merge(df1,df2,how='left',on='c1')
df8 = pd.merge(df1,df2,how='right',on='c1')
print('df1\n',df1); print('===========')
print('df2\n',df2); print('===========')
print('df3\n',df3); print('===========')
print('df4\n',df4); print('===========')
print('df5\n',df5); print('===========')
print('df6\n',df6); print('===========')
print('df7\n',df7); print('===========')
print('df8\n',df8)
执行结果：
df1
c2 c1
t2 1 C
t1 2 B
===========
df2
c2 c1
t2 3 C
t1 4 A
===========
df3
Empty DataFrame
Columns: [c2, c1]
Index: []
===========
df4
c2_x c1 c2_y
0 1 C 3
===========
df5
c2_x c1 c2_y
0 1.0 C 3.0
1 2.0 B NaN
2 NaN A 4.0
===========
df6
c2_df1 c1 c2_df2
0 NaN A 4.0
1 2.0 B NaN
2 1.0 C 3.0
===========
df7
c2_x c1 c2_y
0 1 C 3.0
1 2 B NaN
===========
df8
c2_x c1 c2_y
0 1.0 C 3
1 NaN A 4
# 例3：以df1的'c1'列为主键，以df2的'c2'列为主键（主键列值相同的合并为一行），会导致丢失行标签信息
import numpy as np
import pandas as pd
# 定义原始数据
df1 = pd.DataFrame([[1,'C'],[2,'B']], columns=['c3','c1'], index=['t2','t1'])
df2 = pd.DataFrame([[3,'C'],[4,'A']], columns=['c3','c2'], index=['t2','t1'])
# 开始合并
df3 = pd.merge(df1,df2,left_on='c1',right_on='c2')
df4 = pd.merge(df1,df2,how='outer',left_on='c1',right_on='c2')
df5 = pd.merge(df1,df2,how='outer',left_on='c1',right_on='c2',sort=True,suffixes=('_df1','_df2'))
df6 = pd.merge(df1,df2,how='left',left_on='c1',right_on='c2')
df7 = pd.merge(df1,df2,how='right',left_on='c1',right_on='c2')
print('df1\n',df1); print('===========')
print('df2\n',df2); print('===========')
print('df3\n',df3); print('===========')
print('df4\n',df4); print('===========')
print('df5\n',df5); print('===========')
print('df6\n',df6); print('===========')
print('df7\n',df7)
执行结果：
df1
c3 c1
t2 1 C
t1 2 B
===========
df2
c3 c2
t2 3 C
t1 4 A
===========
df3
c3_x c1 c3_y c2
0 1 C 3 C
===========
df4
c3_x c1 c3_y c2
0 1.0 C 3.0 C
1 2.0 B NaN NaN
2 NaN NaN 4.0 A
===========
df5
c3_df1 c1 c3_df2 c2
0 NaN NaN 4.0 A
1 2.0 B NaN NaN
2 1.0 C 3.0 C
===========
df6
c3_x c1 c3_y c2
0 1 C 3.0 C
1 2 B NaN NaN
===========
df7
c3_x c1 c3_y c2
0 1.0 C 3 C
1 NaN NaN 4 A
13. Series和DataFrame的层次化索引
由于在最新版本的Pandas中已将该Panel数据类型删除，因此可以使用层次化索引间接实现Panel数据类型的效果
（1）Series的层次化索引
① 创建层次化索引的Series
语法和创建普通Series的语法相同，只须把index变为多维结构即可。定义了层次化索引的Series后，s.index的数据类型变成了pandas.core.indexes.multi.MultiIndex
靠前的索引（如下例中的大写字母）是外层索引，其level值为0；靠后的索引（如下例中的小写字母）是内层索引，其level值以整数递增（本例中其level=1）。
import numpy as np
import pandas as pd
s = pd.Series([1,2,3,4,5,6,7,8],
index=[
['A','A','B','B','C','C','D','D'],
['e','f','e','g','f','h','g','h']
])
print('s','\n',s); print('===========')
print('s.index','\n',s.index,'\n',type(s.index))
执行结果：
s
A e 1
f 2
B e 3
g 4
C f 5
h 6
D g 7
h 8
dtype: int64
===========
s.index
MultiIndex([('A', 'e'),
('A', 'f'),
('B', 'e'),
('B', 'g'),
('C', 'f'),
('C', 'h'),
('D', 'g'),
('D', 'h')],
)
<class 'pandas.core.indexes.multi.MultiIndex'>
② 层次化索引的Series的索引和切片
import numpy as np
import pandas as pd
s = pd.Series([1,2,3,4,5,6,7,8],
index=[
['A','A','B','B','C','C','D','D'],
['e','f','e','g','f','h','g','h']
])
print('s','\n',s); print('===========')
print("s['A']",'\n',s['A'],'\n',type(s['A'])); print('===========')
print("s['A':'C']",'\n',s['A':'C'],'\n',type(s['A':'C'])); print('===========')
print("s[['A','C']]",'\n',s[['A','C']],'\n',type(s[['A','C']])); print('===========')
print("s[:,'f']",'\n',s[:,'f'],'\n',type(s[:,'f'])); print('===========')
print("s['A','e']",'\n',s['A','e'],'\n',type(s['A','e'])); print('===========')
# 下面几种形式会导致报错：
# print(s['A':'C','f'])
# print(s[['A','C'],'f'])
# print(s[:,'e':'f'])
# print(s[:,['e','f']])
执行结果：
s
A e 1
f 2
B e 3
g 4
C f 5
h 6
D g 7
h 8
dtype: int64
===========
s['A']
e 1
f 2
dtype: int64
<class 'pandas.core.series.Series'>
===========
s['A':'C']
A e 1
f 2
B e 3
g 4
C f 5
h 6
dtype: int64
<class 'pandas.core.series.Series'>
===========
s[['A','C']]
A e 1
f 2
C f 5
h 6
dtype: int64
<class 'pandas.core.series.Series'>
===========
s[:,'f']
A 2
C 5
dtype: int64
<class 'pandas.core.series.Series'>
===========
s['A','e']
1
<class 'numpy.int64'>
③ 层次化索引的Series的分组聚合
s.sum(level=0)与s.groupby(level=0).sum()等效
s.sum(level=1)与s.groupby(level=1).sum()等效
import numpy as np
import pandas as pd
s = pd.Series([1,2,3,4,5,6,7,8],
index=[
['A','A','B','B','C','C','D','D'],
['e','f','e','g','f','h','g','h']
])
print('s','\n',s); print('===========')
s1 = s.sum(level=0)
s2 = s.sum(level=1)
s3 = s.groupby(level=0).sum()
s4 = s.groupby(level=1).sum()
print('s1','\n',s1,'\n',type(s1)); print('===========')
print('s2','\n',s2,'\n',type(s2)); print('===========')
print('s3','\n',s3,'\n',type(s3)); print('===========')
print('s4','\n',s4,'\n',type(s4))
执行结果：
s
A e 1
f 2
B e 3
g 4
C f 5
h 6
D g 7
h 8
dtype: int64
===========
s1
A 3
B 7
C 11
D 15
dtype: int64
<class 'pandas.core.series.Series'>
===========
s2
e 4
f 7
g 11
h 14
dtype: int64
<class 'pandas.core.series.Series'>
===========
s3
A 3
B 7
C 11
D 15
dtype: int64
<class 'pandas.core.series.Series'>
===========
s4
e 4
f 7
g 11
h 14
dtype: int64
<class 'pandas.core.series.Series'>
（2）DataFrame的层次化索引
① 创建层次化索引的DataFrame
语法和创建普通DataFrame的语法相同，只须把index变为多维结构即可。定义了层次化索引的DataFrame后，df.index的数据类型变成了pandas.core.indexes.multi.MultiIndex
靠前的索引（如下例中的大写字母）是外层索引，其level值为0；靠后的索引（如下例中的小写字母）是内层索引，其level值以整数递增（本例中其level=1）。
关于层次化索引的df.index.name和df.index.names的区别，见本章“二、Pandas模块 - 5. DataFrame对象的属性 - （3）df.index.name和df.index.names”
import numpy as np
import pandas as pd
# 创建方式一
df = pd.DataFrame([1,2,3,4,5,6,7,8])
df.columns = ['c1']
df.index = [['A','A','B','B','C','C','D','D'],
['e','f','e','g','f','h','g','h']]
df.index.name='my_index_name'
df.index.names = ['i1','i2']
# 创建方式二（两种方式等效）
"""
df = pd.DataFrame([['A','e',1],
['A','f',2],
['B','e',3],
['B','g',4],
['C','f',5],
['C','h',6],
['D','g',7],
['D','h',8]])
df.columns=['i1','i2','c1']
df = df.set_index(['i1','i2'])
df.index.name='my_index_name'
"""
print('df\n',df,'\n',type(df)); print('===========')
print('df.index\n',df.index,'\n',type(df.index)); print('-----------')
print(df.index.name); print('-----------')
print(df.index.names); print('===========')
print('df.columns\n',df.columns,'\n',type(df.columns))
执行结果：
df
c1
i1 i2
A e 1
f 2
B e 3
g 4
C f 5
h 6
D g 7
h 8
<class 'pandas.core.frame.DataFrame'>
===========
df.index
MultiIndex([('A', 'e'),
('A', 'f'),
('B', 'e'),
('B', 'g'),
('C', 'f'),
('C', 'h'),
('D', 'g'),
('D', 'h')],
name='my_index_name')
<class 'pandas.core.indexes.multi.MultiIndex'>
-----------
my_index_name
-----------
['i1', 'i2']
===========
df.columns
Index(['c1'], dtype='object')
<class 'pandas.core.indexes.base.Index'>
② 层次化索引的DataFrame的索引和切片
import numpy as np
import pandas as pd
df = pd.DataFrame([1,2,3,4,5,6,7,8],columns=['c1'],
index=[
['A','A','B','B','C','C','D','D'],
['e','f','e','g','f','h','g','h']
])
print('df\n',df,'\n',type(df)); print('===========')
print("df.loc['A']",'\n',df.loc['A'],'\n',type(df.loc['A'])); print('===========')
print("df.loc['A':'C']",'\n',df.loc['A':'C'],'\n',type(df.loc['A':'C'])); print('===========')
print("df.loc[['A','C']]",'\n',df.loc[['A','C']],'\n',type(df.loc[['A','C']])); print('===========')
print("df.loc[('A','f')]",'\n',df.loc[('A','f')],'\n',type(df.loc[('A','f')])); print('===========')
print("df.loc[('A','f'),'c1']",'\n',df.loc[('A','f'),'c1'],'\n',type(df.loc[('A','f'),'c1'])); print('===========')
# 下面的写法将导致错误：
# print("df.loc[:,'f']",'\n',df.loc[:,'f'],'\n',type(df.loc[:,'f'])); print('===========')
# print("df.loc[(:,'f')]",'\n',df.loc[(:,'f')],'\n',type(df.loc[(:,'f')])); print('===========')
# print("df.loc[('A','f':'h')]",'\n',df.loc[('A','f':'h')],'\n',type(df.loc[('A','f':'h')])); print('===========')
# print("df.loc[(['A','C'],'f')]",'\n',df.loc[(['A','C'],'f')],'\n',type(df.loc[(['A','C'],'f')])); print('===========')
# print("df.loc[('A',['f','h'])]",'\n',df.loc[('A',['f','h'])],'\n',type(df.loc[('A',['f','h'])])); print('===========')
执行结果：
df
c1
A e 1
f 2
B e 3
g 4
C f 5
h 6
D g 7
h 8
<class 'pandas.core.frame.DataFrame'>
===========
df.loc['A']
c1
e 1
f 2
<class 'pandas.core.frame.DataFrame'>
===========
df.loc['A':'C']
c1
A e 1
f 2
B e 3
g 4
C f 5
h 6
<class 'pandas.core.frame.DataFrame'>
===========
df.loc[['A','C']]
c1
A e 1
f 2
C f 5
h 6
<class 'pandas.core.frame.DataFrame'>
===========
df.loc[('A','f')]
c1 2
Name: (A, f), dtype: int64
<class 'pandas.core.series.Series'>
===========
df.loc[('A','f'),'c1']
2
<class 'numpy.int64'>
③ 层次化索引的DataFrame的分组聚合
df.sum(level=0)与df.groupby(level=0).sum()等效
df.sum(level=1)与df.groupby(level=1).sum()等效
import numpy as np
import pandas as pd
df = pd.DataFrame([1,2,3,4,5,6,7,8],columns=['c1'],
index=[
['A','A','B','B','C','C','D','D'],
['e','f','e','g','f','h','g','h']
])
print('df\n',df,'\n',type(df)); print('===========')
df1 = df.sum(level=0)
df2 = df.groupby(level=0).sum()
df3 = df.sum(level=1)
df4 = df.groupby(level=1).sum()
print('df1','\n',df1,'\n',type(df1)); print('===========')
print('df2','\n',df2,'\n',type(df2)); print('===========')
print('df3','\n',df3,'\n',type(df3)); print('===========')
print('df4','\n',df4,'\n',type(df4))
执行结果：
df
c1
A e 1
f 2
B e 3
g 4
C f 5
h 6
D g 7
h 8
<class 'pandas.core.frame.DataFrame'>
===========
df1
c1
A 3
B 7
C 11
D 15
<class 'pandas.core.frame.DataFrame'>
===========
df2
c1
A 3
B 7
C 11
D 15
<class 'pandas.core.frame.DataFrame'>
===========
df3
c1
e 4
f 7
g 11
h 14
<class 'pandas.core.frame.DataFrame'>
===========
df4
c1
e 4
f 7
g 11
h 14
<class 'pandas.core.frame.DataFrame'>
④ 重置层次化索引
df.reset_index()：重置所有层次化索引
df.reset_index(level=0)：重置level=0的层次化索引
df.reset_index(level=1)：重置level=1的层次化索引
也可以重新设定df.index.levels，详见本章5.DataFrame对象的属性 - （4）df.index.levels
（3）使用unstack()和stack()对层次化索引的Series和DataFrame进行变形（行标签与列标签的转换）
stack: v.堆栈，unstack：v.拆栈
s.unstack()的效果为：将s最内层行标签（纵向）进行转置变为列标签（横向），若转置后数据的行数变为1，则为Series类型数据，否则为DataFrame类型数据
s.stack()：报错，Series数据类型没有stack()方法，因为Series数据类型没有可供转置用的列标签
df.unstack()的效果为：将df最内层行标签（纵向）进行转置变为列标签（横向），若转置后数据的行数变为1，则为Series类型数据，否则为DataFrame类型数据
df.stack()的效果为：将df列标签（横向）进行转置变为最内层行标签（纵向），若转置后数据的列数变为1，则为Series类型数据，否则为DataFrame类型数据
# Series的数据变形的例子
import numpy as np
import pandas as pd
s = pd.Series([1,2,3,4,5,6,7,8],
index=[
['A','A','B','B','C','C','D','D'],
['e','f','e','g','f','h','g','h']
])
# s_s = s.stack() # 导致报错
s_u = s.unstack()
s_us = s.unstack().stack() # 又变回了s
s_uu = s.unstack().unstack() # 实现了内、外层索引的互转
print('s\n',s,'\n',type(s)); print('===========')
# print('s_s\n',s_s,'\n',type(s_s)); print('===========') # 导致报错
print('s_u\n',s_u,'\n',type(s_u)); print('===========')
print('s_us\n',s_us,'\n',type(s_us)); print('===========')
print('s_uu\n',s_uu,'\n',type(s_uu))
执行结果：
s
A e 1
f 2
B e 3
g 4
C f 5
h 6
D g 7
h 8
dtype: int64
<class 'pandas.core.series.Series'>
===========
s_u
e f g h
A 1.0 2.0 NaN NaN
B 3.0 NaN 4.0 NaN
C NaN 5.0 NaN 6.0
D NaN NaN 7.0 8.0
<class 'pandas.core.frame.DataFrame'>
===========
s_us
A e 1.0
f 2.0
B e 3.0
g 4.0
C f 5.0
h 6.0
D g 7.0
h 8.0
dtype: float64
<class 'pandas.core.series.Series'>
===========
s_uu
e A 1.0
B 3.0
C NaN
D NaN
f A 2.0
B NaN
C 5.0
D NaN
g A NaN
B 4.0
C NaN
D 7.0
h A NaN
B NaN
C 6.0
D 8.0
dtype: float64
<class 'pandas.core.series.Series'>
# DataFrame的数据变形的例子
import numpy as np
import pandas as pd
df = pd.DataFrame([1,2,3,4,5,6,7,8],columns=['t1'],
index=[
['A','A','B','B','C','C','D','D'],
['e','f','e','g','f','h','g','h']
])
df_s = df.stack()
df_u = df.unstack()
df_us = df.unstack().stack() # 又变回了df
df_uu = df.unstack().unstack()
print('df\n',df,'\n',type(df)); print('===========')
print('df_s\n',df_s,'\n',type(df_s)); print('===========')
print('df_u\n',df_u,'\n',type(df_u)); print('===========')
print('df_us\n',df_us,'\n',type(df_us)); print('===========')
print('df_uu\n',df_uu,'\n',type(df_uu))
执行结果：
df
t1
A e 1
f 2
B e 3
g 4
C f 5
h 6
D g 7
h 8
<class 'pandas.core.frame.DataFrame'>
===========
df_s
A e t1 1
f t1 2
B e t1 3
g t1 4
C f t1 5
h t1 6
D g t1 7
h t1 8
dtype: int64
<class 'pandas.core.series.Series'>
===========
df_u
t1
e f g h
A 1.0 2.0 NaN NaN
B 3.0 NaN 4.0 NaN
C NaN 5.0 NaN 6.0
D NaN NaN 7.0 8.0
<class 'pandas.core.frame.DataFrame'>
===========
df_us
t1
A e 1.0
f 2.0
B e 3.0
g 4.0
C f 5.0
h 6.0
D g 7.0
h 8.0
<class 'pandas.core.frame.DataFrame'>
===========
df_uu
t1 e A 1.0
B 3.0
C NaN
D NaN
f A 2.0
B NaN
C 5.0
D NaN
g A NaN
B 4.0
C NaN
D 7.0
h A NaN
B NaN
C 6.0
D 8.0
dtype: float64
<class 'pandas.core.series.Series'>
14. Pandas中的时间相关格式及方法
（1）Pandas中的时间格式及特殊索引、切片方法
① pandas._libs.tslibs.timestamps.Timestamp：时间戳
② pandas.core.indexes.datetimes.DatetimeIndex：时间格式索引
③ pandas._libs.tslibs.period.Period：时期
④ pandas.core.indexes.period.PeriodIndex：时期格式索引
其中，②是由①组成的，④是由③组成的
当一个DataFrame拥有②或者④格式的行标签索引时，它将支持下面各种灵活的索引、切片方式（注意：对频率为月的④类型行标签索引，索引该月的任意一天即视为索引该月；对频率为年的④类型行标签索引，索引该年的任意一天即视为索引该年）：
# 精确索引，只能使用df.loc[]和df.ix[]方式
# df['2019-12-31'] # 精确索引不能使用df[]格式，会导致报错
# df['2019.12.31'] # 精确索引不能使用df[]格式，会导致报错
df.loc['20191231']
df.loc['2019-12-31']
df.loc[pd.datetime(2019,12,31)]
df.ix['20191231']
df.ix['2019-12-31']
df.ix[pd.datetime(2019,12,31)]
...
# 模糊索引，可以使用df[]、df.loc[]和df.ix[]方式
df['2019-12']
df['2019.12']
df['2019']
df.loc['2019-12']
df.loc['2019.12']
df.loc['2019']
df.ix['2019-12']
df.ix['2019.12']
df.ix['2019']
...
# 混合使用精确索引和模糊索引进行切片
df['2019-08':'2019-09-22']
df.loc['2019-08':'2019-09-22']
df.ix['2019-08':'2019-09-22']
...
（2）pd.Timestamp()
语法：pd.Timestamp(n)
返回一个pandas._libs.tslibs.timestamps.Timestamp对象
参数n：经过时间原点的纳秒（10的负9次方秒）数
import numpy as np
import pandas as pd
t1 = pd.Timestamp(0)
t2 = pd.Timestamp(1)
print(t1)
print(t2)
print(type(t2))
执行结果：
1970-01-01 00:00:00
1970-01-01 00:00:00.000000001
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
（3）pd.datetime()
语法：pd.datetime(年,月,日)
返回一个datetime.datetime对象
import numpy as np
import pandas as pd
t = pd.datetime(2019,9,22)
print(t)
print(type(t))
执行结果：
2019-09-22 00:00:00
<class 'datetime.datetime'>
（4）pd.to_datetime()
语法：pd.to_datetime(“看着像日期”的数据类型或其组成的list、ndarray、Series)
将“看着像日期”的数据类型（或其组成的list、ndarray、Series）转换为pandas._libs.tslibs.timestamps.Timestamp类型数据（或pandas.core.indexes.datetimes.DatetimeIndex类型数据）
独立的None会转换为None，但是列表中的None则会转换为NaT（pandas._libs.tslibs.nattype.NaTType类的实例化对象）
可使用df['列标签'] = pd.to_datetime(df['列标签']) 的形式将df中的某列从str类型转换为时间类型
可使用df.index = pd.to_datetime(df.index) 的形式将df中的行索引从str类型转换为时间类型
import numpy as np
import pandas as pd
# print(pd.to_datetime('2019922')) 导致报错
print(pd.to_datetime('20190922'),type(pd.to_datetime('20190922'))); print('-----------')
print(pd.to_datetime(['2019-09-22','2019.09.23']))
print(pd.to_datetime(['2019-9-22','2019.9.23']))
print(pd.to_datetime(['Sept 22 2019','September 23rd, 2019'])); print('===========')
print(pd.to_datetime(None),type(pd.to_datetime(None))); print('-----------')
print(pd.to_datetime([None])); print(type(pd.to_datetime([None])));
print(pd.to_datetime([None])[0]); print(type(pd.to_datetime([None])[0])); print('===========')
print(pd.to_datetime(
np.array(['20190922','20190923'])
)); print('-----------')
print(pd.to_datetime(
pd.Series(['20190922','20190923'])
))
执行结果：
2019-09-22 00:00:00 <class 'pandas._libs.tslibs.timestamps.Timestamp'>
-----------
DatetimeIndex(['2019-09-22', '2019-09-23'], dtype='datetime64[ns]', freq=None)
DatetimeIndex(['2019-09-22', '2019-09-23'], dtype='datetime64[ns]', freq=None)
DatetimeIndex(['2019-09-22', '2019-09-23'], dtype='datetime64[ns]', freq=None)
===========
None <class 'NoneType'>
-----------
DatetimeIndex(['NaT'], dtype='datetime64[ns]', freq=None)
<class 'pandas.core.indexes.datetimes.DatetimeIndex'>
NaT
<class 'pandas._libs.tslibs.nattype.NaTType'>
===========
DatetimeIndex(['2019-09-22', '2019-09-23'], dtype='datetime64[ns]', freq=None)
-----------
0 2019-09-22
1 2019-09-23
dtype: datetime64[ns]
（5）pd.DatetimeIndex()
输入一个由“看着像日期”的数据类型组成的一维list，将其中的每一项元素转为pandas._libs.tslibs.timestamps.Timestamp类型后，整体以pandas.core.indexes.datetimes.DatetimeIndex类型返回
列表中的None会转换为NaT（pandas._libs.tslibs.nattype.NaTType类的实例化对象）
可使用df['列标签'] = pd.DatetimeIndex(df['列标签']) 的形式将df中的某列从str类型转换为时间类型
import datetime
import numpy as np
import pandas as pd
dti1 = pd.DatetimeIndex(['20190101','20190102',None])
dti2 = pd.DatetimeIndex(['2019-01-01','2019-01-02'])
dti3 = pd.DatetimeIndex(['Jan 1,2019','January 2nd, 2019'])
dti4 = pd.DatetimeIndex([datetime.datetime(2019,1,1),datetime.datetime(2019,1,2)])
dti5 = pd.DatetimeIndex([pd.datetime(2019,1,1),pd.datetime(2019,1,2)])
dti6 = pd.DatetimeIndex([pd.Timestamp(0),pd.Timestamp(1e18)])
print(dti1,'\n',type(dti1[0]))
print(dti2,'\n',type(dti2[0]))
print(dti3,'\n',type(dti3[0]))
print(dti4,'\n',type(dti4[0]))
print(dti5,'\n',type(dti5[0]))
print(dti6,'\n',type(dti6[0]))
执行结果：
DatetimeIndex(['2019-01-01', '2019-01-02', 'NaT'], dtype='datetime64[ns]', freq=None)
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
DatetimeIndex(['2019-01-01', '2019-01-02'], dtype='datetime64[ns]', freq=None)
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
DatetimeIndex(['2019-01-01', '2019-01-02'], dtype='datetime64[ns]', freq=None)
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
DatetimeIndex(['2019-01-01', '2019-01-02'], dtype='datetime64[ns]', freq=None)
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
DatetimeIndex(['2019-01-01', '2019-01-02'], dtype='datetime64[ns]', freq=None)
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
DatetimeIndex(['1970-01-01 00:00:00', '2001-09-09 01:46:40'], dtype='datetime64[ns]', freq=None)
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
（6）pd.date_range()
语法：pd.date_range(start=None, end=None, periods=None, freq='D')
生成由若干个pandas._libs.tslibs.timestamps.Timestamp对象组成的pandas.core.indexes.datetimes.DatetimeIndex对象
参数：
start：起始日期
end：终止日期
periods：长度（数据个数）
-
freq：频率（相邻数据的间隔时间），默认值为1天
'D'。可以改成诸如30秒'30S'、5分钟'5T'、2小时'2H'、3天'3D'、2周'2W'、每月最后一天'M'、每月第一天'MS'、1年'Y'等形式。此外，频率以'B'为单位时代表工作日，但是这个工作日仅仅代表周一到周五，不考虑法定节假日。此项参数的其他复杂取值：名称 说明 W-MON 周-星期一 WOM-1MON 月-第1个星期一 Q-JAN 季度，以一月最后一日结束（可把JAN换成FEB, MAR） QS-JAN 季度，以一月第一日结束（可把JAN换成FEB, MAR） A-JAN 年，以一月最后一个日历日结束（可把JAN换成FEB,...,DEC） AS-JAN 年，以一月第一个日历日结束（可把JAN换成FEB,...,DEC）
注意：
参数freq默认值为
'D'，start、end、periods三个参数，至少要输入两个，否则报错-
pd.date_range()常用于给df.index赋值，以便生成行标签，如：
...
df.index = pd.date_range('2019-9-22', periods=5, freq='M') -
pd.date_range()生成的DatetimeIndex对象可以用索引方式来取值，如：
...
t = pd.date_range('2019-9-22', periods=5, freq='M')
print(t[0]) 不可以直接用字符串来判断其是否等于返回结果中的某一个日期，可以用pd.datetime()来判断。不过，对于DataFrame中的pd.date_range()类型的标签索引，既可以使用pd.datetime()进行标签索引，也可以使用字符串进行标签索引
代码示例：
import numpy as np
import pandas as pd
import warnings; warnings.simplefilter('ignore') # 忽略可能会出现的警告信息；警告并不是错误，可以忽略；可能出现警告的场景包括：df.ix[]、pd.concat()
t1 = pd.date_range('2019-9-22', periods=2, freq='3D')
t2 = pd.date_range('2019-9-22', periods=2, freq='2W')
t3 = pd.date_range('2019-9-22', periods=3, freq='M')
t4 = pd.date_range('2019-9-22', periods=3, freq='Y')
print('t1','\n',t1,'\n',type(t1),'\n',t1[0],'\n',type(t1[0])); print('-----------')
print('t2','\n',t2); print('-----------')
print('t3','\n',t3); print('-----------')
print('t4','\n',t4); print('===========')
print(t1[0] == '2019-9-22') # 错误的判断方式
print(t1[0] == '2019-09-22') # 错误的判断方式
print(t1[0] == pd.datetime(2019,9,22)) # 正确的判断方式
执行结果：
t1
DatetimeIndex(['2019-09-22', '2019-09-25'], dtype='datetime64[ns]', freq='3D')
<class 'pandas.core.indexes.datetimes.DatetimeIndex'>
2019-09-22 00:00:00
<class 'pandas._libs.tslibs.timestamps.Timestamp'>
-----------
t2
DatetimeIndex(['2019-09-22', '2019-10-06'], dtype='datetime64[ns]', freq='2W-SUN')
-----------
t3
DatetimeIndex(['2019-09-30', '2019-10-31', '2019-11-30'], dtype='datetime64[ns]', freq='M')
-----------
t4
DatetimeIndex(['2019-12-31', '2020-12-31', '2021-12-31'], dtype='datetime64[ns]', freq='A-DEC')
===========
False
False
True
（7）pd.period_range()
语法：pd.period_range(start=None, end=None, periods=None, freq='D')
生成由若干个pandas._libs.tslibs.period.Period对象组成的pandas.core.indexes.period.PeriodIndex对象
参数：
- start：起始日期
- end：终止日期
- periods：长度（数据个数）
- freq：频率（相邻数据的间隔时间），默认值为1天
'D'。可以改成诸如30秒'30S'、5分钟'5T'、2小时'2H'、3天'3D'、每周一'W-Mon'、2周'2W'、1个月'M'、1年'Y'等形式。此外，频率以'B'为单位时代表工作日，但是这个工作日仅仅代表周一到周五，不考虑法定节假日。当频率以月为单位时，产生的数据中仅有年、月；当频率以年为单位时，产生的数据中仅有年。
注意：
参数freq默认值为
'D'时，start、end、periods三个参数，至少要输入两个，否则报错-
pd.period_range()常用于给df.index赋值，以便生成行标签，如：
...
df.index = pd.period_range('2019-9-22', periods=5, freq='W') -
pd.period_range()生成的PeriodIndex对象可以用索引方式来取值，如：
...
p = pd.period_range('2019-9-22', periods=5, freq='M')
print(p[0]) 不可以直接用字符串来判断其是否等于返回结果中的某一个日期，也不能用pd.datetime()来判断。不过，对于DataFrame中的pandas.core.indexes.period.PeriodIndex类型的标签索引，既可以使用pd.datetime()进行标签索引，也可以使用字符串进行标签索引（对频率为月的pandas.core.indexes.period.PeriodIndex类型行标签索引，索引该月的任意一天即视为索引该月；对频率为年的pandas.core.indexes.period.PeriodIndex类型行标签索引，索引该年的任意一天即视为索引该年）
代码示例：
# 不可以直接用字符串来判断其是否等于返回结果中的某一个日期，也不能用pd.datetime()来判断
import numpy as np
import pandas as pd
p1 = pd.period_range('2019-9-22', periods=2, freq='3D')
p2 = pd.period_range('2019-9-22', periods=2, freq='2W')
p3 = pd.period_range('2019-9-22', periods=3, freq='M')
p4 = pd.period_range('2019-9-22', periods=3, freq='Y')
print('p1','\n',p1,'\n',type(p1),'\n',p1[0],'\n',type(p1[0])); print('-----------')
print('p2','\n',p2); print('-----------')
print('p3','\n',p3); print('-----------')
print('p4','\n',p4); print('===========')
print(p1[0] == '2019-9-22') # 错误的判断方式
print(p1[0] == '2019-09-22') # 错误的判断方式
print(p1[0] == pd.datetime(2019,9,22)) # 错误的判断方式
执行结果：
p1
PeriodIndex(['2019-09-22', '2019-09-25'], dtype='period[3D]', freq='3D')
<class 'pandas.core.indexes.period.PeriodIndex'>
2019-09-22
<class 'pandas._libs.tslibs.period.Period'>
-----------
p2
PeriodIndex(['2019-09-16/2019-09-22', '2019-09-30/2019-10-06'], dtype='period[2W-SUN]', freq='2W-SUN')
-----------
p3
PeriodIndex(['2019-09', '2019-10', '2019-11'], dtype='period[M]', freq='M')
-----------
p4
PeriodIndex(['2019', '2020', '2021'], dtype='period[A-DEC]', freq='A-DEC')
===========
False
False
False
# 频率为日的索引示例
import numpy as np
import pandas as pd
np.random.seed(0)
arr = np.random.randn(5,2)
p = pd.period_range('2019-9-22', periods=5, freq='D') # 频率为日
df = pd.DataFrame(arr, columns=['c1','c2'], index=p)
print(df); print('===========')
print(df.loc['2019-9-22']); print('===========')
print(df.loc[pd.datetime(2019,9,22)])
执行结果：
c1 c2
2019-09-22 1.764052 0.400157
2019-09-23 0.978738 2.240893
2019-09-24 1.867558 -0.977278
2019-09-25 0.950088 -0.151357
2019-09-26 -0.103219 0.410599
===========
c1 1.764052
c2 0.400157
Name: 2019-09-22, dtype: float64
===========
c1 1.764052
c2 0.400157
Name: 2019-09-22, dtype: float64
# 频率为月的索引示例
import numpy as np
import pandas as pd
np.random.seed(0)
arr = np.random.randn(5,2)
p = pd.period_range('2019-9-22', periods=5, freq='M') # 频率为月
df = pd.DataFrame(arr, columns=['c1','c2'], index=p)
print(df); print('-----------')
print(df.loc['20190922']); print('-----------')
print(df.loc['2019-9-23']); print('-----------')
print(df.loc[pd.datetime(2019,9,22)]); print('-----------')
print(df.loc[pd.datetime(2019,9,23)])
执行结果：
c1 c2
2019-09 1.764052 0.400157
2019-10 0.978738 2.240893
2019-11 1.867558 -0.977278
2019-12 0.950088 -0.151357
2020-01 -0.103219 0.410599
-----------
c1 1.764052
c2 0.400157
Name: 2019-09, dtype: float64
-----------
c1 1.764052
c2 0.400157
Name: 2019-09, dtype: float64
-----------
c1 1.764052
c2 0.400157
Name: 2019-09, dtype: float64
-----------
c1 1.764052
c2 0.400157
Name: 2019-09, dtype: float64
# 频率为年的索引示例
import numpy as np
import pandas as pd
np.random.seed(0)
arr = np.random.randn(5,2)
p = pd.period_range('2019-9-22', periods=5, freq='Y') # 频率为年
df = pd.DataFrame(arr, columns=['c1','c2'], index=p)
print(df); print('-----------')
print(df.loc['20190922']); print('-----------')
print(df.loc['2019-9-23']); print('-----------')
print(df.loc[pd.datetime(2019,9,22)]); print('-----------')
print(df.loc[pd.datetime(2019,9,23)])
执行结果：
c1 c2
2019 1.764052 0.400157
2020 0.978738 2.240893
2021 1.867558 -0.977278
2022 0.950088 -0.151357
2023 -0.103219 0.410599
-----------
c1 1.764052
c2 0.400157
Name: 2019, dtype: float64
-----------
c1 1.764052
c2 0.400157
Name: 2019, dtype: float64
-----------
c1 1.764052
c2 0.400157
Name: 2019, dtype: float64
-----------
c1 1.764052
c2 0.400157
Name: 2019, dtype: float64
（8）pd.date_range()和pd.period_range()的对比
相同点：
- 返回值可以作为DataFrame的行标签索引，并支持df[]形式的特殊索引
- 返回值都可以作为DataFrame数据中的一列
不同点：
- freq='M'、freq='Y'时显示的数据不同
- 数据类型不同
- 由于数据类型不同，导致个别的属性和方法不同（这里不再展开）
（9）df.resample()：重采样
resample：v.重采样
对行索引为pandas.core.indexes.datetimes.DatetimeIndex或pandas.core.indexes.period.PeriodIndex类型的DataFrame进行重采样（频率调整），具体步骤为：
首先，获取DataFrame格式数据df
-
接着，使用
resample_obj = df.resample(rule,axis=0,closed=None)获取resample对象（pandas.core.resample.DatetimeIndexResampler类型）参数：
- rule：调整后的频率，如：
'S'（秒）、'T'或'min'（分钟）、'H'（小时）、'D'（天）、'W'（周）、'M'（月）、'Q'（季度）、'A'或'Y'（年），还可以在字母前加上数字，如：'3D'（3天） - axis：默认值为0，按列处理；axis=1时按行处理（一般无须指定此参数）
- closed：时间区间的闭合方式，left为前闭，right为后闭（一般无须指定此参数）
- rule：调整后的频率，如：
-
最后，应用resemple对象的相应方法进行处理，如：
- 高频调整为低频（降采样）适用的方法：
-
resample_obj.mean()：使用对应时间段内所有数据的平均值进行聚合 -
resample_obj.max()：使用对应时间段内所有数据的最大值进行聚合（最高价聚合常用） -
resample_obj.min()：使用对应时间段内所有数据的最小值进行聚合（最低价聚合常用） -
resample_obj.median()：使用对应时间段内所有数据的中位数进行聚合 -
resample_obj.sum()：使用对应时间段内所有数据的和进行聚合（成交量聚合常用） -
resample_obj.prod()：使用对应时间段内所有数据的乘积进行聚合 -
resample_obj.std()：使用对应时间段内所有数据的标准差进行聚合 -
resample_obj.var()：使用对应时间段内所有数据的方差进行聚合 -
resample_obj.count()：使用对应时间段内所有非空数据的计数进行聚合 -
resample_obj.first()：使用对应时间段内的第一个数据进行聚合（开盘价聚合常用） -
resample_obj.last()：使用对应时间段内的最后一个数据进行聚合（收盘价聚合常用） -
resample_obj.nunique()：使用对应时间段内有多少个不同的值来进行聚合 -
resample_obj.asfreq()：使用显示的日期所对应的数据进行聚合（比如将日数据降采样为月数据，显示的是每月最后一天，就使用这天的数据进行聚合，但是每月最后一天可能不是交易日没有数据，此时这条数据就是NaN） -
resample_obj.ohlc()：使用对应时间段内所有数据的open、high、low、close四项特征数据进行聚合 -
resample_obj.apply(<func>)：使用自定义的聚合函数，apply()方法的详细解释本章“10. DataFrame对象的方法和Pandas模块的方法 -（5）其他方法”，示例代码见本节下面
-
- 低频调整为高频（升采样）适用的方法：
-
resample_obj.ffill()：使用向前填充法处理空值 -
resample_obj.pad()：使用向前填充法处理空值 -
resample_obj.bfill()：使用向后填充法处理空值 -
resample_obj.fillna()：使用fillna()方法处理空值 - 线性插值法：
-
resample_obj.interpolate()：使用线性插值法填充两个数据之间的空值，简便，推荐 -
df.interpolate()：也可以不基于resample对象，手动在两条数据间插入指定数量的空值，然后使用DataFrame对象自带的插值法进行填充，详见本章“9. DataFrame的空值（NaN）处理-（5）df.interpolate()”。但是这样操作过于复杂，不推荐
-
-
resample_obj.apply(<func>)：使用自定义的插值函数，每次传到func()里的是对应时间段的数据组成的Series或DataFrame，详见本章“10. DataFrame对象的方法和Pandas模块的方法 -（5）其他重要方法 - ①df.apply()”
-
- 高频调整为低频（降采样）适用的方法：
注意：讲义中提到的df.resample('M', how='mean')里的how参数已弃用，以上述新方法为准。
① 高频调整为低频（降采样）：通过聚合实现
注意：聚合后的索引是聚合前的索引在该时间段内的最后一个值（若日数据按照月重采样，则索引变为每个月的最后一天）
# 基于收益率的resample_obj.mean()和resample_obj.apply(<func>)方法示例
import pandas as pd
import numpy as np
# 读取本地文件'000001.csv'
data = pd.read_csv('000001.csv', index_col=0, parse_dates=True)
# 使用收盘价计算每日收益率
data_return = data['close'] / data['close'].shift()
# 获取频率为月的resample对象
resample_obj = data_return.resample('M')
print(resample_obj,'\n',type(resample_obj)); print('===========')
# 使用对应月份所有数据的平均值进行聚合（两种方式等效）
print(resample_obj.mean()); print('-----------')
print(resample_obj.apply(lambda x: x.mean())); print('===========') # 当只有一列时，x为Series；当有多列时，x为DataFrame
# 检验聚合结果是否正确
print(data_return['2017-03'].mean().round(6)); print('===========')
print(data_return['2019-07'].mean().round(6))
执行结果：
DatetimeIndexResampler [freq=<MonthEnd>, axis=0, closed=right, label=right, convention=start, base=0]
<class 'pandas.core.resample.DatetimeIndexResampler'>
===========
date
2017-02-28 1.005302
2017-03-31 0.998575
...
2019-07-31 1.001199
2019-08-31 1.000752
Freq: M, Name: close, dtype: float64
-----------
date
2017-02-28 1.005302
2017-03-31 0.998575
...
2019-07-31 1.001199
2019-08-31 1.000752
Freq: M, Name: close, dtype: float64
===========
0.998575
===========
1.001199
# 基于收盘价的resample_obj.ohlc()方法示例
import pandas as pd
import numpy as np
# 读取本地文件'000001.csv'
data = pd.read_csv('000001.csv', index_col=0, parse_dates=True)
# 获取每日收盘价
data_close = data['close']
# 获取频率为1个月的resample对象
resample_obj = data_close.resample('M')
print(resample_obj,'\n',type(resample_obj)); print('===========')
# 使用对应时间段内所有数据的open、high、low、close四项特征数据进行聚合
print(resample_obj.ohlc()); print('===========')
# 检验OHLC结果是否正确
print(data_close['2017-03-01'])
print(data_close['2017-04'].max())
print(data_close['2019-06'].min())
print(data_close['2019-07-31'])
执行结果：
DatetimeIndexResampler [freq=<MonthEnd>, axis=0, closed=right, label=right, convention=start, base=0]
<class 'pandas.core.resample.DatetimeIndexResampler'>
===========
open high low close
date
2017-02-28 9.43 9.48 9.43 9.48
2017-03-31 9.49 9.52 9.08 9.17
2017-04-30 9.21 9.21 8.91 8.99
...
2019-06-30 11.90 13.80 11.85 13.78
2019-07-31 13.93 14.37 13.54 14.13
2019-08-31 14.10 15.12 13.35 14.25
===========
9.49
9.21
11.85
14.13
② 低频调整为高频（升采样）：通过线性插值实现
注意：若使用resample_obj.interpolate()方法，则插值前的索引是插值后的索引在该时间段的第一个值（假设日数据按照小时重采样，则每天的实际值变为该日00:00:00的值）
# 基于收盘价的resample_obj.interpolate()方法示例
import pandas as pd
import numpy as np
# 读取本地文件'000001.csv'
data = pd.read_csv('000001.csv', index_col=0, parse_dates=True)
# 获取前两天的收盘价
data_close = data['close'][1:3]
print(data_close); print('===========')
# 获取频率为1小时的resample对象
resample_obj = data_close.resample('H')
print(resample_obj,'\n',type(resample_obj)); print('===========')
# 使用线性插值法填补中间空缺的数据
print(resample_obj.interpolate())
执行结果：
date
2017-02-28 9.48
2017-03-01 9.49
Name: close, dtype: float64
===========
DatetimeIndexResampler [freq=<Hour>, axis=0, closed=left, label=left, convention=start, base=0]
<class 'pandas.core.resample.DatetimeIndexResampler'>
===========
date
2017-02-28 00:00:00 9.480000
2017-02-28 01:00:00 9.480417
2017-02-28 02:00:00 9.480833
2017-02-28 03:00:00 9.481250
...
2017-02-28 21:00:00 9.488750
2017-02-28 22:00:00 9.489167
2017-02-28 23:00:00 9.489583
2017-03-01 00:00:00 9.490000
Freq: H, Name: close, dtype: float64
（10）df.rolling()：滑动时间窗
对DataFrame或Series类型数据进行滑动时间窗处理，具体步骤为：
- 首先，获取DataFrame格式数据df（或Series类型数据s）
- 接着，使用
rolling_obj = df.rolling(window, min_periods=None, center=False)获取rolling对象（pandas.core.window.Rolling类型），参数：- window：时间窗大小，即时间窗中包含几个数据，必须输入（int类型）
- min_periods：在边界处使时间窗计算结果不为NaN的最小数据量，默认为None，此时时间窗中必须有window个数据才会计算结果，否则显示NaN；指定min_periods后，时间窗中只要有min_periods个数据就可以计算结果。
- center：时间窗标签是否居中，默认为False，此时时间窗标签为时间窗内最后一个时间点（即时间窗内最后一行的行标签）；center=True时，时间窗标签为时间窗内中间位置的时间点（即时间窗内中间一行的行标签）
- 最后，应用rolling对象的相应方法进行处理，如：
-
rolling_obj.mean()：使用时间窗内所有数据的平均值作为时间窗标签对应的值（移动平均SMA） -
rolling_obj.max()：使用时间窗内所有数据的最大值作为时间窗标签对应的值 -
rolling_obj.min()：使用时间窗内所有数据的最小值作为时间窗标签对应的值 -
rolling_obj.sum()：使用时间窗内所有数据的和作为时间窗标签对应的值 -
rolling_obj.std()：使用时间窗内所有数据的标准差作为时间窗标签对应的值 -
rolling_obj.apply(<func>)：编写自定义函数func，将时间窗内所有数据作为参数传递给func，并将func的返回值作为时间窗标签对应的值
-
# 滑动时间窗示例
import pandas as pd
import numpy as np
# 读取本地文件'000001.csv'
data = pd.read_csv('000001.csv', index_col=0, parse_dates=True)
# 获取每日收盘价
data_close = data['close']
# 获取不同参数的rolling对象
rolling_obj3 = data_close.rolling(3)
rolling_obj32 = data_close.rolling(3, min_periods=2)
rolling_obj31 = data_close.rolling(3, min_periods=1)
rolling_obj3c = data_close.rolling(3, center=True)
# 使用rolling对象进行滑动时间窗处理
print('data_close\n',data_close); print('===========')
print(rolling_obj3,type(rolling_obj3)); print('===========')
print('rolling_obj3.mean()\n',rolling_obj3.mean()); print('===========')
print('rolling_obj32.mean()\n',rolling_obj32.mean()); print('===========')
print('rolling_obj31.mean()\n',rolling_obj31.mean()); print('===========')
print('rolling_obj3c.mean()\n',rolling_obj3c.mean())
执行结果：
data_close
date
2017-02-27 9.43
2017-02-28 9.48
2017-03-01 9.49
2017-03-02 9.43
2017-03-03 9.40
...
2019-08-20 14.99
2019-08-21 14.45
2019-08-22 14.31
2019-08-23 14.65
2019-08-26 14.25
Name: close, Length: 613, dtype: float64
===========
Rolling [window=3,center=False,axis=0] <class 'pandas.core.window.Rolling'>
===========
rolling_obj3.mean()
date
2017-02-27 NaN
2017-02-28 NaN
2017-03-01 9.466667
2017-03-02 9.466667
2017-03-03 9.440000
...
2019-08-20 14.936667
2019-08-21 14.786667
2019-08-22 14.583333
2019-08-23 14.470000
2019-08-26 14.403333
Name: close, Length: 613, dtype: float64
===========
rolling_obj32.mean()
date
2017-02-27 NaN
2017-02-28 9.455000
2017-03-01 9.466667
2017-03-02 9.466667
2017-03-03 9.440000
...
2019-08-20 14.936667
2019-08-21 14.786667
2019-08-22 14.583333
2019-08-23 14.470000
2019-08-26 14.403333
Name: close, Length: 613, dtype: float64
===========
rolling_obj31.mean()
date
2017-02-27 9.430000
2017-02-28 9.455000
2017-03-01 9.466667
2017-03-02 9.466667
2017-03-03 9.440000
...
2019-08-20 14.936667
2019-08-21 14.786667
2019-08-22 14.583333
2019-08-23 14.470000
2019-08-26 14.403333
Name: close, Length: 613, dtype: float64
===========
rolling_obj3c.mean()
date
2017-02-27 NaN
2017-02-28 9.466667
2017-03-01 9.466667
2017-03-02 9.440000
2017-03-03 9.426667
...
2019-08-20 14.786667
2019-08-21 14.583333
2019-08-22 14.470000
2019-08-23 14.403333
2019-08-26 NaN
Name: close, Length: 613, dtype: float64