fly_Xiaoma

详解Pandas用法_02

原文地址：http://www.huaxiaozhuan.com/%E5%B7%A5%E5%85%B7/pandas/chapters/pandas.html

六、数据清洗

1. 移除重复数据

2. apply

3. 缺失数据

4. 离散化

七、字符串操作

八、聚合与分组

1. 分组

2. GroupBy对象

3. 分组级运算

4. 透视表和交叉表

九、时间序列

1. Python 中的时间

2. 时间点 Timestamp

3. 时间段 Period

4. DatetimeIndex

5. PeriodIndex

6. resample 和频率转换

十、 DataFrame 绘图

十二、数据加载和保存

1. 文本文件

2. Json

3. 二进制文件

4. Excel 文件

5. HTML 表格

6. SQL

六、数据清洗

1. 移除重复数据

Series/DataFrame.duplicated(*args, **kwargs)：返回一个布尔Series，指示调用者中，哪些行是重复的（重复行标记为True）。
- keep：一个字符串或者False，指示如何标记。它代替了废弃的参数take_last
  - 'first'：对于重复数据，第一次出现时标记为False，后面出现时标记为True
  - 'last'：对于重复数据，最后一次出现时标记为False，前面出现时标记为True
  - False：对于重复数据，所有出现的地方都标记为True
而Series/DataFrame.drop_duplicates(*args, **kwargs)：返回重复行被移除之后的Series/DataFrame。
- keep：一个字符串或者False，指示如何删除。它代替了废弃的参数take_last
  - 'first'：对于重复数据，保留第一次出现，后面出现时删除
  - 'last'：对于重复数据，最后一次出现时保留，前面出现时删除
  - False：对于重复数据，删除所有出现的位置
- inplace：一个布尔值。如果为True，则原地修改。否则返回新建的对象。
对于DataFrame，还有个 subset参数。它是column label或者其列表，给出了考虑哪些列的重复值。默认考虑所有列。（即一行中哪些字段需要被考虑）

2. apply

你可以使用numpy的ufunc函数操作pandas对象。
有时，你希望将函数应用到由各列或者各行形成的一维数组上，此时DataFrame的.apply()方法即可实现此功能。 .apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)
- func：一个可调用对象，它会应用于每一行或者每一列
- axis：指定应用于行还是列。如果为0/'index'，则沿着0轴计算（应用于每一列）；如果为1/'columns'，则沿着1轴计算（应用于每一行）。
- broadcast：一个布尔值，如果为True，则结果为DataFrame（不足的部分通过广播来填充）
- raw：一个布尔值。如果为False，则转换每一行/每一列为一个Series，然后传给 func 作为参数。如果True，则func接受到的是ndarray，而不是Series
- reduce：一个布尔值。用于判断当DataFrame为空时，应该返回一个Series还是返回一个DataFrame。如果为True，则结果为Series；如果为False，则结果为DataFrame。
- args：传递给func的额外的位置参数（第一个位置参数始终为Series/ndarray）
有时，你希望将函数应用到DataFrame中的每个元素，则可以使用.applymap(func)方法。之所以不叫map，是因为Series已经有个.map方法。
Series的.apply()方法应用到Series的每个元素上： .apply(func, convert_dtype=True, args=(), **kwds)
- func：一个可调用对象，它会应用于每个元素
- convert_dtype：一个布尔值。如果为True，则pandas会自动匹配func结果的最佳dtype；如果为False，则dtype=object
- args：传递给func的额外的位置参数。
- kwds：传递给func的额外的关键字参数。
返回结果可能是Series，也可能是DataFrame（比如，func返回一个Series)
Series的.map(arg,na_action=None)方法会应用到Series的每个元素上：
- arg：一个函数、字典或者Series。如果为字典或者Series，则它是一种映射关系，键/index label就是自变量，值就是返回值。
- na_action：如果为ignore，则忽略NaN
返回相同index的一个Series

3. 缺失数据

pands对象上的所有描述统计都排除了缺失数据。
DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)：根据各label的值中是否存在缺失数据来对轴label进行过滤。
- axis：指定沿着哪个轴进行过滤。如果为0/'index'，则沿着0轴；如果为1/'columns'，则沿着1轴。你也可以同时提供两个轴（以列表或者元组的形式）
- how：指定过滤方式。如果为'any'，则如果该label对应的数据中只要有任何NaN，则抛弃该label；如果为'all'，则如果该label对应的数据中必须全部为NaN才抛弃该label。
- thresh：一个整数，要求该label必须有thresh个非NaN才保留下来。它比how的优先级较高。
- subset：一个label的array-like。比如axis=0，则subset为轴 1 上的标签，它指定你考虑哪些列的子集上的NaN
- inplace：一个布尔值。如果为True，则原地修改。否则返回一个新创建的DataFrame
对于Series，其签名为： Series.dropna(axis=0, inplace=False, **kwargs)
DataFrame/Series.fillna(value=None, method=None, axis=None, inplace=False, limit=None,downcast=None, **kwargs)：用指定值或者插值方法来填充缺失数据。
- value：一个标量、字典、Series或者DataFrame。注意：value与method只能指定其中之一，不能同时提供。
  - 如果为标量，则它指定了填充NaN的数据。
  - 如果为Series/dict，则它指定了填充每个index的数据
  - 如果为DataFrame，则它指定了填充每个DataFrame单元的数据
- method：指定填充方式。可以为None，也可以为：
  - 'backfill'/'bfill'：使用下一个可用的有效值来填充（后向填充）
  - 'ffill'/'pad'：使用前一个可用的有效值来填充（前向填充）
- axis：指定沿着哪个轴进行填充。如果为0/'index'，则沿着0轴；如果为1/'columns'，则沿着1轴
- inplace：一个布尔值。如果为True，则原地修改。否则返回一个新创建的DataFrame
- limit：一个整数。如果method提供了，则当有连续的N个NaN时，只有其中的limit个NaN会被填充（注意：对于前向填充和后向填充，剩余的空缺的位置不同）
- downcast：一个字典，用于类型转换。字典形式为： {label->dtype}，dtype可以为字符串，也可以为np.float64等。
DataFrame/Series.isnull()：返回一个同样尺寸的布尔类型的对象，来指示每个值是否是null

DataFrame/Series.notnull()：返回一个同样尺寸的布尔类型的对象，来指示每个值是否是not null
fillna()方法可以看作是值替换的一种特殊情况。更通用的是值替换replace()方法。
```
 
```
```
 
```
```
  Series/DataFrame.replace(to_replace=None, value=None, inplace=False, limit=None, 
```
```
  regex=False, method='pad', axis=None) 
```
- to_replace：一个字符串、正则表达式、列表、字典、Series、数值、None。指示了需要被替换的那些值
  - 字符串：则只有严格等于该字符串的那些值才被替换
  - 正则表达式：只有匹配该正则表达式的那些值才被替换（regex=True）
  - 列表：
    - 如果to_place 和value都是列表，则它们必须长度严格相等
    - 如果regex=True，则列表中所有字符串都是正则表达式。
  - 字典：字典的键对应了被替换的值，字典的值给出了替换值。如果是嵌套字典，则最外层的键给出了column名
  - None：此时regex必须是个字符串，该字符串可以表示正则表达式、列表、字典、ndarray等。如果value也是None，则to_replace必须是个嵌套字典。
- value：一个字符串、正则表达式、列表、字典、Series、数值、None。给出了替换值。如果是个字典，则键指出了将填充哪些列（不在其中的那些列将不被填充）
- inplace：一个布尔值。如果为True，则原地修改。否则创建新对象。
- limit：一个整数，指定了连续填充的最大跨度。
- regex：一个布尔值，或者与to_replace类型相同。
  - 如果为True，则to_replace必须是个字符串。
  - 如果是个字符串，则to_replace必须为None，因为它会被视作过滤器
- method：指定填充类型。可以为'pad'/'ffill'/'bfill'。当to_replace是个列表时该参数有效。
interpolate是通过前后数据插值来填充NaN。
```
 
```
```
 
```
```
  Series/DataFrame.interpolate(method='linear', axis=0, limit=None, inplace=False,
```
```
  limit_direction='forward', downcast=None, **kwargs)
```
- method：一个字符串，指定插值的方法。
  - 'linear'：线性插值。只有它支持MultiIndex
  - 'index'/'values'：使用索引标签的整数下标来辅助插值
  - 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',
  'barycentric', 'polynomial'使用scipy.interpolate.interp1d。对于'polynomial'/'spline'，你需要传入一个order（一个整数）
  - 'krogh', 'piecewise_polynomial', 'spline', 'pchip','akima'也使用了scipy的插值算法。它们使用索引标签的整数下标来辅助插值。
  - 'time'： interpolation works on daily and higher resolution data to interpolate given length of interval
- axis：指定插值的轴。如果为0/'index'则沿着0 轴；如果为1/'columns'则沿着 1 轴
- limit：一个整数，指定插值时，如果有K个连续的NaN，则只插值其中的limit个
- limit_direction：一个字符串。当设定了limit时，指定处理前面limit个NaN，还是后面limit个NaN。可以为'forward'/'backward'/'both'
- inplace：一个布尔值。如果为True，则原地修改。否则创建新对象。
- downcast：指定是否自动向下执行类型转换、
- 其他参数是传递给scipy的插值函数的。

4. 离散化

连续数据常常会被离散化或者拆分成面元bin。可以通过pandas.cut()函数来实现：
```
 
```
```
 
```
```
  pandas.cut(x, bins, right=True, labels=None, retbins=False, precision=3,
```
```
  include_lowest=False)
```
- x：一维的数据。
- bins：一个整数或者一个序列。
  - 整数：它指定了划分区间的数量。每个区间是等长的，且最左侧的区间的左侧比x最小值小0.1%；最右侧的区间的右侧比x最大值大0.1%。
  - 一个序列：它给出了bins的每个划分点。
- right：一个布尔值。如果为True，则区间是左开右闭；否则区间是左闭右开的区间。
- labels：一个array或者None。如果为一个array，则它指定了结果bins的label（要求长度与bins数量相同）。如果为None，则使用区间来表示。
- retbins：一个布尔值。如果为True，则返回bins
- precision：一个整数，给出存储和显示bin label的精度
- include_lowest：一个布尔值。如果为True，则最左侧bin的左侧是闭区间
返回的是一个Categorical对象或者Series对象。该函数类似于numpy.histogram()函数。
另外一个划分的函数是：
```
 
```
```
 
```
```
 pandas.qcut(x, q, labels=None, retbins=False, precision=3)
```
- q：一个整数或者序列。
  - 整数：它指定了划分区间的数量。
  - 一个序列：它给出了百分比划分点。比如[0,0.25,0.5,0.75,0.1]。0.25代表25%划分点。如果数据不在任何区间内，则标记为NaN。
- 其他参数与cut相同。(qcut没有bins参数）

七、字符串操作

通过Series.map()方法，所有字符串和正则表达式方法都能应用于各个值。但是如果存在NaN就会报错。为了解决这个问题，pandas提供了一些能够跳过NaN值的字符串操作方法。
Series.str能够将Series的值当作字符串处理，并且你可以通过Series.str.func来应用某些函数。其中func可以为：
- Series.str.capitalize()
- Series.str.cat([others, sep, na_rep])
- Series.str.center(width[, fillchar])
- Series.str.contains(pat[, case=True, flags=0, na=nan, regex=True])
- Series.str.count(pat[, flags])
- Series.str.decode(encoding[, errors])
- Series.str.encode(encoding[, errors])
- Series.str.endswith(pat[, na])
- Series.str.extract(pat[, flags, expand])
- Series.str.extractall(pat[, flags])
- Series.str.find(sub[, start, end])
- Series.str.findall(pat[, flags])
- Series.str.get(i)
- Series.str.index(sub[, start, end])
- Series.str.join(sep)
- Series.str.len()
- Series.str.ljust(width[, fillchar])
- Series.str.lower()
- Series.str.lstrip([to_strip])
- Series.str.match(pat[, case=True, flags=0, na=nan, as_indexer=False])
- Series.str.normalize(form)
- Series.str.pad(width[, side, fillchar])
- Series.str.partition([pat, expand])
- Series.str.repeat(repeats)
- Series.str.replace(pat, repl[, n, case, flags])
- Series.str.rfind(sub[, start, end])
- Series.str.rindex(sub[, start, end])
- Series.str.rjust(width[, fillchar])
- Series.str.rpartition([pat, expand])
- Series.str.rstrip([to_strip])
- Series.str.slice([start, stop, step])
- Series.str.slice_replace([start, stop, repl])
- Series.str.split([pat, n, expand])
- Series.str.rsplit([pat, n, expand])
- Series.str.startswith(pat[, na])
- Series.str.strip([to_strip])
- Series.str.swapcase()
- Series.str.title()
- Series.str.translate(table[, deletechars])
- Series.str.upper()
- Series.str.wrap(width, **kwargs)
- Series.str.zfill(width)
- Series.str.isalnum()
- Series.str.isalpha()
- Series.str.isdigit()
- Series.str.isspace()
- Series.str.islower()
- Series.str.isupper()
- Series.str.istitle()
- Series.str.isnumeric()
- Series.str.isdecimal()
- Series.str.get_dummies([sep])
你也可以通过Series.str[:3]这种索引操作来进行子串截取。或者使用Series.str.get()方法进行截取。

八、聚合与分组

1. 分组

分组运算的过程为：拆分-应用-合并
- 拆分阶段：Series/DataFrame等数据根据你提供的一个或者多个键，被拆分为多组
- 应用阶段：根据你提供的一个函数应用到这些分组上
- 合并阶段：将函数的执行结果合并到最终结果中
分组中有两种数据：源数据（被分组的对象），分组数据（用于划分源数据的）。
- 源数据每一行(axis=0) 对应于分组数据中的一个元素。分组数据中每一个唯一值对应于一个分组。
- 当分组数据也在源数据中时，可以直接通过指定列名来指定分组数据（值相同的为同一组）。
.groupby()方法是分组方法：
```
 
```
```
 
```
```
  Series/DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, 
```
```
  group_keys=True, squeeze=False, **kwargs)
```
- by：一个mapping function、list of function、一个字典、一个序列、一个元组、一个list of column name。它指定了分组数据。
  - 如果传入了函数，则在每个index value上调用函数来产生分组数据
  - 如果是Series或者字典，则根据每个index value在字典/Series中的值来产生分组数据
  - 如果是个column label，则使用该label抽取出来的一列数据产生分组数据
  - 如果是个column label的list，则使用一组column label抽取出来的多列数据作为分组数据。
  - 如果是个序列，则它直接指定了分组数据。
  - 如果是个序列的序列，则使用这些序列拼接成一个MulitiIndex，然后根据这个MultiIndex替换掉index后，根据label value来分组。（事实上并没有替换，只是用于说明这个过程）
    
    如果axis=1，则index label替换成column label
- axis：指定沿着哪个轴分组。可以为0/'index'，表示沿着 0轴。可以为1/'columns'，表示沿着 1轴
- level：一个整数、level name或者其序列。如果axis是个MultiIndex，则在指定级别上的索引来分组
- as_index：一个布尔值。如果为True，则将group label作为输出的index。如果为False，则输出是SQL风格的分组（此时分组的key作为一列，而不是作为index）。Series中，该参数必须为True。
- sort：一个布尔值。如果为True，则对分组的键进行排序。
- group_keys：一个布尔值。如果为True，且调用了函数来决定分组，则添加分组键来区分不同的数据（否则你不知道每一行数据都对应于哪里）
- squeeze：一个布尔值。如果为True，则尽可能的缩减结果的类型。
该函数返回一个GroupBy对象。
我们可以使用dtype来分组，此时by=df.dtypes,axis=1：
对于由DataFrame产生的GroupBy对象，我们可以用一个或者一组列名对其索引。它其实一个语法糖。
- 如果索引是一个列名，则df.groupby('key1')['data1'] 等价于df['data1'].groupby(df['key1'])
- 如果索引是一个元组和序列，则 df.groupby('key1')[['data1','data2']] 并不等价于 df[['data1','data2']].groupby(df['key1'])，而是等同于 df.groupby(df['key1'])
  - 之所以用 [['data1','data2']]，是因为df[['data1','data2']]与df['data1','data2']语义不同。后者表示某个label是个元组，该元组的值为'data1','data2'。

2. GroupBy对象

GroupBy对象是一个迭代器对象。迭代结果产生一组二元元组（由分组名和数据块组成）。
- 如果有多重键，则元组的第一个元素将是由键组成的元组。
- dict(list(GroupBy_obj))将生产一个字典，方便引用
- GroupBy.groups属性返回一个字典： {group name->group labels}
- GroupBy.indices属性返回一个字典：{group name->group indices}

GroupBy的统计函数有（排除了NaN）：

GroupBy.count() ：计算各分组的非NaN的数量
GroupBy.cumcount([ascending])：计算累积分组数量
GroupBy.first()：计算每个分组的第一个非NaN值
GroupBy.head([n]) ：返回每个分组的前 n个值
GroupBy.last() ：计算每个分组的最后一个非NaN值
GroupBy.max()：计算每个分组的最大值
GroupBy.mean(*args, **kwargs)：计算每个分组的均值
GroupBy.median()：计算每个分组的中位数
GroupBy.min()：计算每个分组的最小值
GroupBy.nth(n[, dropna])：计算每个分组第n行数据。如果n是个整数列表，则也返回一个列表。
GroupBy.ohlc()：计算每个分组的开始、最高、最低、结束值
GroupBy.prod()：计算每个分组的乘
GroupBy.size()：计算每个分组的大小（包含了NaN）
GroupBy.sem([ddof]) ：计算每个分组的sem（与均值的绝对误差之和）
GroupBy.std([ddof]) ：计算每个分组的标准差
GroupBy.sum()：计算每个分组的和
GroupBy.var([ddof])：计算每个分组的方差
GroupBy.tail([n]) ：返回每个分组的尾部 n个值

另外SeriesGroupBy/DataFrameGroupBy也支持Series/DataFrame的统计类方法以及其他方法：

  #SeriesGroupBy - DataFrameGroupBy 都有的方法：

  .agg(arg, *args, **kwargs)

  .all([axis, bool_only, ...])

  .any([axis, bool_only, ...])

  .bfill([limit])

  .corr([method, min_periods])

  .count()

  .cov([min_periods])

  .cummax([axis, skipna])

  .cummin([axis, skipna])

  .cumprod([axis])

  .cumsum([axis])

  .describe([percentiles, ...])

  .diff([periods, axis])

  .ffill([limit])

  .fillna([value, method, ...])

  .hist(data[, column, by, ...])

  .idxmax([axis, skipna])

  .idxmin([axis, skipna])

  .mad([axis, skipna, level])

  .pct_change([periods, ...])

  .plot

  .quantile([q, axis, ...])

  .rank([axis, method, ...])

  .resample(rule, *args, **kwargs)

  .shift([periods, freq, axis])

  .size()

  .skew([axis, skipna, level, ...])

  .take(indices[, axis, ...])

  .tshift([periods, freq, axis])

  #SeriesGroupBy独有的方法

  SeriesGroupBy.nlargest(*args, **kwargs)

  SeriesGroupBy.nsmallest(*args, **kwargs)

  SeriesGroupBy.nunique([dropna])

  SeriesGroupBy.unique()

  SeriesGroupBy.value_counts([normalize, ...])

  #DataFrameGroupBy独有的方法

  DataFrameGroupBy.corrwith(other[, axis, drop])

  DataFrameGroupBy.boxplot(grouped[, ...])

如果你希望使用自己的聚合函数，只需要将其传入.aggregate(func, *args, **kwargs)或者.agg()方法即可。其中func接受一维数组，返回一个标量值。
- 注意：自定义聚合函数会慢得多。这是因为在构造中间分组数据块时存在非常大的开销（函数调用、数据重排等）
- 你可以将前面介绍的GroupBy的统计函数名以字符串的形式传入。
- 如果你传入了一组函数或者函数名，则得到的结果中，相应的列就用对应的函数名命名。如果你希望提供一个自己的名字，则使用(name,function)元组的序列。其中name用作结果列的列名。
- 如果你希望对不同的列采用不同的聚合函数，则向agg()传入一个字典。字典的键就是列名，值就是你希望对该列采用的函数。
.get_group(key)可以获取分组键对应的数据。
- key ：不同的分组就是依靠它来区分的
GroupBy的下标操作将获得一个只包含源数据中指定列的新GroupBy对象
GroupBy类定义了__getattr__()方法，当获取GroupBy中未定义的属性时：
- 如果属性名是源数据对象的某列的名称则，相当于GroupBy[name]，即获取针对该列的GroupBy对象
- 如果属性名是源数据对象的方法，则相当于通过.apply(name)对每个分组调用该方法。

3. 分组级运算

agg/aggregate只是分组级运算其中的一种。它接受一维数组，返回一个标量值。
transform是另一个分组级运算。它也接受一维数组。只能返回两种结果：要么是一个标量值（该标量值将被广播），或者一个相同大小的结果数组。
- 你无法通过字典来对不同的列进行不同的transform
```
 
```
```
 
```
```
  GroupBy.transform(func, *args, **kwargs)
```
apply是另一个分组级运算。它是最一般化的分组级运算。它将待处理的对象拆分成多个片段，然后对各个片段调用传入的函数，最后尝试将各个片段组合到一起。
```
 
```
```
 
```
```
  GroupBy.apply(func, *args, **kwargs) 
```
- func：运算函数。其第一个位置参数为待处理对象。其返回值是一个标量值或者pandas对象。
- args/kwargs是传递给func的额外的位置参数与关键字参数。
对于DataFrame的.groupby时，传递给func的第一个参数是DataFrame；对于Series的.groupby，传递给func的第一个参数是Series。
pd.cut()/qcut()函数返回的是Categorical对象。我们可以用它作为.groupby()的by参数的值。这样可以实现桶分析。

4. 透视表和交叉表

透视表pivot table是一种数据汇总工具。它根据一个或者多个键对数据进行聚合，并根据行和列上的分组键将数据分配到各个单元格中。
- 你可以通过.groupby功能以及索引的变换来手工实现这种功能
DataFrame.pivot_table()方法，以及pandas.pivot_table()函数都可以实现这种功能
```
 
```
```
 
```
```
  pandas.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', 
```
```
  fill_value=None, margins=False, dropna=True, margins_name='All')
```
- data：一个DataFrame对象
- values：指定哪些列将被聚合。默认聚合所有的数值列。
- index：一个index label、一个Grouper、一个数组，或者前面这些类型的一个列表。它指定关于分组的列名或者其他分组键，出现在结果透视表的行
- columns：一个column label、一个Grouper、一个数组，或者前面这些类型的一个列表。它指定关于分组的列名或者其他分组键，出现在结果透视表的列
- aggfunc：一个函数或者函数的列表。默认为numpy.mean。它作为聚合函数。如果为函数的列表，则结果中会出现多级索引，函数名就是最外层的索引名。
- fill_value：一个标量，用于替换NaN
- margins：一个布尔值。如果为True，则添加行/列的总计。
- dropna：一个布尔值。如果为True，则结果不包含这样的列：该列所有元素都是NaN
- margins_name：一个字符串。当margins=True时，margin列的列名。
交叉表cross-tabulation:crosstab是一种用于计算分组频率的特殊透视表。我们可以使用pivot_table()函数实现透视表的功能，但是直接使用更方便：
```
 
```
```
 
```
```
  pandas.crosstab(index, columns, values=None, rownames=None, colnames=None, 
```
```
  aggfunc=None, margins=False, dropna=True, normalize=False) 
```
- index：一个array-like、Series或者前两种的列表。它给出了行的计算频数的数据。
- columns：一个array-like、Series或者前两种的列表。它给出了列的计算频数的数据。
- values：一个array-like，该数据用于聚合。如果出现了values，则必须提供aggfunc。
- aggfunc：一个函数对象，是聚合函数。如果出现了aggfunc，则必须提供values。
- rownames：一个序列。如果非空，则必须和结果的row index的level数量相等
- colnames：一个序列。如果非空，则必须和结果的column index的level数量相等
- margins：一个布尔值。如果为True，则添加行/列的总计。
- dropna：一个布尔值。如果为True，则结果不包含这样的列：该列所有元素都是NaN
- normalize：一个布尔值、字符串（'all'/'index'/'columns'）、或者整数0/1。它指定是否进行归一化处理（归一化为频率），否则就是频数。
  - 如果'all'/True，则对所有数据进行归一化
  - 如果为'index'：则对每一行归一化
  - 如果为'columns'：则对每一列归一化
  - 如果margins为True，则对margins也归一化。
values的作用是这样的：首先根据index-columns建立坐标。行坐标来自index，列坐标来自columns。在index-columns-values中，同一个坐标下的values组成Series。这个Series被aggfunc进行聚合，aggfunc接受一个Series，返回一个标量。此时就不再是对坐标点进行计数了，而是对values进行聚合。

九、时间序列

Pandas 提供了表示时间点、时间段、时间间隔等三种与时间有关的类型，以及元素为这些类型的索引对象。pandas还提供了许多与时间序列相关的函数。

1. Python 中的时间

Python中，关于时间、日期处理的库有三个：time、datetime、Calendar。其中：datetime又有datetime.date/datetime.time/datetime.datetime三个类

1.1 时区

所有的时间都有一个时区。同样一个时间戳，根据不同的时区，它可以转换成不同的时间。
pytz模块的common_timezones可以获取常用的表示时区的字符串。你可以通过pytz.timezone('timezone_str')来创建时区对象。

1.2 time 模块

time模块中，时间有三种表现形式：
- Unix时间戳。指的是从1970年以来的秒数
- 本地时间的struct_time形式：一个命名元组，第一位为年、第二位为月....
- UTC时间的struct_time的形式：类似于上面的，只是为UTC时间。区别在于：前者是本地时间local time，后者是UTC时间
查看当前时间的三种表现形式：
- Unix时间戳： time.time()
- local struct_time： time.localtime()
- utc struct_time：time.gmtime()
三种格式之间的转换：
- timestamp--->local time：time.localtime(time_stamp)
- timestamp--->utc time：time.gmtime(time_stamp)
- local time--->timestamp：time.mktime(local_time)
- utc time---> timestamp：calendar.timegm(utc_time)
三种格式的时间转换为字符串：
- timestamp：time.ctime(time_stamp)
- local struct_time time/utc struct_time time：time.asctime(struct_time)
- 对于local struct_time time/utc struct_time time：你也可以使用time.strftime(format_str,struct_time) 来自定义格式化串。其中format_str为格式化串。
字符串转换为struct_time：time.strptime(time_str,format_str)。其中format_str为格式化串。
查看当前时区： time.timezone。它返回的是距离UTC时间的距离（单位为秒）（>0，在美洲;<=0，在大多数欧洲，亚洲，非洲）。你无法通过修改它的值来修改时区。time模块使用的是系统的时区。

1.3 datetime 模块

datetime模块中主要包含四个类：
- datetime.time：时间类。只包含时、分、秒、微秒等时间信息
- datetime.date：日期类。值包含年月日星期等日期信息
- datetime.datetime：日期时间类。包含上述两者的全部信息
- datetime.timedelta：日期时间间隔类，用来表示两个datetime之间的差值。
datetime.time的构造函数为：
```
 
```
```
 
```
```
  time([hour[, minute[, second[, microsecond[, tzinfo]]]]])
```
其中tzinfo就是时区对象。0<=hour<24，0<=minute<60，0<=second<60，0<=microsecond<1000000，否则抛出异常。tzinfo默认为None

属性有：

hour/minute/second/microsecond/tzinfo

方法有：

time.replace([hour[, minute[, second[, microsecond[, tzinfo]]]]])：替换对应的值，返回一个新的对象
time.isoformat()：返回一个ISO 8601格式的字符串。
time.strftime(format)：格式化datetime.time对象
time.tzname()：如果时区为为None，则返回None。否则返回时区名称

datetime.date的构造函数为：
```
 
```
```
 
```
```
  datetime.date(year, month, day) 
```
- month取值为[1,12]；day取值为[1,num]，num取决于指定的年和月有多少天
类方法有：date.today()/date.fromtimestamp(timestamp)

属性有：year/month/day

方法有：
- 运算：date1-date2、date1+timedelta、date1-timedelta、date1

 
    datetime.datetime的构造函数为：
  
  
  
   datetime.datetime(year, month, day, hour=0, minute=0, 
   second=0, microsecond=0, tzinfo=None)
 类方法有： 
     
     datetime.today()：返回当前的时间日期 
     datetime.now(tz=None)：返回指定时区当前的时间日期。如果tz=None，则等价于datetime.today() 
     datetime.utcnow()：返回当前的UTC时间日期 
     datetime.fromtimestamp(timestamp, tz=None)：根据时间戳，创建指定时区下的时间日期。 
     datetime.utcfromtimestamp(timestamp)：根据时间戳，创建UTC下的时间日期。 
     datetime.combine(date, time)：从date和time对象中创建datetime 
     datetime.strptime(date_string, format)：从字符串中创建datetime 
    
属性有：year/month/day/hour/minute/second/microsecond/tzinfo
 方法有： 
     
     运算：datetime1-datetime2、datetime1+timedelta、 datetime1-timedelta、datetime1
 
     datetime.date()：返回一个date对象 
     datetime.time()：返回一个time对象（该time的tzinfo=None） 
     datetime.timetz()：返回一个time对象（该time的tzinfo为datetime的tzinfo） 
     datetime.replace([year[, month[, day[, hour[, minute[, second [, microsecond[, tzinfo]]]]]]]])：替换掉指定值，返回新对象 
     datetime.astimezone(tz=None) ：调整时区。如果tz=None，则默认采用系统时区。注意，调整前后的UTC时间是相同的。 
     datetime.tzname()：返回时区名字 
     datetime.timetuple()：返回一个time.struct_time这样的命名元组 
     datetime.utctimetuple()：返回一个time.struct_time这样的命名元组，注意它是在UTC时间下的，而不是local time下的 
     datetime.timestamp()：返回一个时间戳 
     datetime.weekday()：返回代表星期几的数字。0为周日 
     datetime.isoweekday()：返回代表星期几的数字。7为周日 
     datetime.isocalendar()：返回一个元组(ISO year,IOS week num,ISO weekday) 
     datetime.isoformat(sep='T')：返回一个ISO 8601格式的字符串。 
     datetime.ctime()：等价于time.ctime(time.mktime(d.timetuple())) 
     datetime.strftime(format)：格式化datetime.datetime对象。 
    
注意：不能将tzinfo=None和tzinfo!=None的两个datetime进行运算。
 
 
    下面是常用的格式化字符串的定义： 
     
     '%Y'：4位数的年 
     '%y'：2位数的年 
     '%m'：2位数的月 [01,12] 
     '%d'：2位数的日 [01,31] 
     '%H'：小时（24小时制）[00,23] 
     '%I'：小时（12小时制）[01,12] 
     '%M'：2位数的分[00,59] 
     '%S'：秒[00,61]，61秒用于闰秒 
     '%w'：用整数表示的星期几[0,6]，0 表示星期日 
     '%U'：每年的第几周[00,53]。星期天表示每周的第一天。每年的第一个星期天之前的那几天被认为是第 0 周 
     '%W'：每年的第几周[00,53]。星期一表示每周的第一天。每年的第一个星期一之前的那几天被认为是第 0 周 
     '%z'：以+HHMM或者-HHMM表示的UTC时区偏移量。如果未指定时区，则返回空字符串。 
     '%F'：以%Y-%m-%d简写的形式 
     '%D'：以%m/%d/%y简写的形式 
     '%a'：星期几的简称 
     '%A'：星期几的全称 
     '%b'：月份的简称 
     '%B'：月份的全称 
     '%c'：完整的日期和时间 
     '%q'：季度[01,04] 
    
  
    timedelta代表一段时间。其构造：
  
  
  
   datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0,
   minutes=0, hours=0, weeks=0) 
 在内部，只存储秒、微秒。其他时间单位都转换为秒和微秒。

 
  实例属性（只读）： 
   
   days/seconds/microseconds 
   
  实例方法： 
   
   timedelta.total_seconds()：返回总秒数。 
   
   
  2. 时间点 Timestamp 
   
    时间点：Timestamp对象从Python的datetime类继承，它表示时间轴上的一个点。
  
  
  
   pd.Timestamp(ts_input=