详解Pandas用法_02

最新推荐文章于 2023-03-19 22:58:43 发布

fly_Xiaoma

最新推荐文章于 2023-03-19 22:58:43 发布

阅读量1k

点赞数

分类专栏： Python

Python 专栏收录该内容

66 篇文章 11 订阅

订阅专栏

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

六、数据清洗

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'。

groupby_sugar

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[, ...])

GroupBy_method0 GroupBy_method1

如果你希望使用自己的聚合函数，只需要将其传入.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_time

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<date2
- date.replace(year,month,day)：替换掉对应值，返回新对象
- date.timetuple()：返回一个time.struct_time类型的元组
- date.weekday()：返回代表星期几的数字。0为周日
- date.isoweekday()：返回代表星期几的数字。7为周日
- date.isocalendar()：返回一个元组(ISO year,IOS week num,ISO weekday)
- date.isoformat()：返回一个ISO 8601格式的字符串。
- date.ctime()：等价于time.ctime(time.mktime(d.timetuple()))
- date.strftime(format)：格式化datetime.date对象
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<datetime2
- 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()：返回总秒数。

datetime_timedelta