详解Pandas用法_02
原文地址: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'
。
- 之所以用
-
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
三个类
- 所有的时间都有一个时区。同样一个时间戳,根据不同的时区,它可以转换成不同的时间。
-
pytz
模块的common_timezones
可以获取常用的表示时区的字符串。你可以通过pytz.timezone('timezone_str')
来创建时区对象。
-
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
模块使用的是系统的时区。
-
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<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()
:返回总秒数。
2. 时间点 Timestamp
-
时间点:
Timestamp
对象从Python
的datetime
类继承,它表示时间轴上的一个点。pd.Timestamp(ts_input=<object object at 0x0000000001E8F340>, freq=None, tz=None,
unit=None, year=None, month=None, day=None, hour=None, minute=None,
second=None, microsecond=None, tzinfo=None, offset=None)
参数:
-
ts_input
:一个datetime-like/str/int/float
,该值将被转换成Timestamp
-
freq
:一个字符串或者DateOffset
,给出了偏移量 -
tz
:一个字符串或者pytz.timezone
对象,给出了时区 -
unit
:一个字符串。当ts_input
为整数或者浮点数时,给出了转换单位 -
offset
:废弃的,推荐使用freq
- 其他的参数来自于
datetime.datetime
。它们要么使用位置参数,要么使用关键字参数,但是不能混用
属性有:
-
year/month/day/hour/minute/second/microsecond/nanosecond
,这些属性都为整数 -
tzinfo
:时区信息(默认为None
),它是一个datetime.tzinfo
对象 dayofweek/dayofyear/days_in_mounth/freqstr/quarter/weekofyear/...
-
value
:保存的是UTC
时间戳(自UNIX
纪元1970年1月1日以来的纳秒数),该值在时区转换过程中保持不变
类方法有:
-
combine(date, time)
:通过datetime.date
和datetime.time
创建一个Timestamp
-
fromtimestamp(ts)
:通过时间戳创建一个Timestamp
-
now(tz=None)
:创建一个指定时区的当前时间。 -
doday(tz=None)
:创建一个指定时区的当前时间。 -
utcfromtimestamp(ts)
:从时间戳创建一个UTC Timestamp
,其tzinfo=None
-
utcnow()
:创建一个当前的UTC Timestamp
,其tzinfo=UTC
方法有:
-
.astimezone(tz)/.tz_convert(tz)
:将一个tz-aware Timestamp
转换时区 -
.isoformat(sep='T')
:返回一个ISO 8601
格式的字符串。 -
.normalize()
:将Timestamp
调整到午夜(保留tzinfo
) -
replace(**kwds)
:调整对应值,返回一个新对象 -
.to_period(self, freq=None)
:返回一个Period
对象` -
.tz_localize(self, tz, ambiguous='raise', errors='raise')
:将一个tz-naive Timestamp
,利用tz
转换为一个tz-aware Timestamp
-
.to_pydatetime(...)
:转换为python datetime
对象 -
.to_datetime64(...)
:转换为numpy.datetime64
对象 - 从
datetime.date/datetime.datetime
继承而来的方法
默认情况下,
pands
中的Timestamp
是tz-naive
,即tz
字段为None
。Timestamp
提供了方便的时区转换功能。如果tz
非空,则是tz-aware Timestamp
。不同时区的时间可以比较,但是naive Timestamp
和localized Timestamp
无法比较。Timestamp
的减法,要求两个Timestamp
要么都是同一个时区下,要么都是tz-naive
的。 -
-
DateOffset
对象:是一个表示日期偏移对象。Timestamp
加一个日期偏移,结果还是一个Timestamp
对象。其声明为:pd.DateOffset(n=1, normalize=False, **kwds)
通常我们使用的是其子类(它们位于
pandas.tseries.offsets
中):-
Day
:日历日 -
BusinessDay
:工作日 -
Hour
:小时 -
Minute
:分钟 -
Second
:秒 -
Milli
:毫秒 -
Micro
:微秒 -
MonthEnd
:每月最后一个日历日 -
BusinessMonthEnd
:每月最后一个工作日 -
MonthBegin
:每月第一个日历日 -
BusinessMonthBegin
:每月第一个工作日 -
Week
:每周几
Day(2)
:表示两个工作日。DateOffset
对象可以加在datetime/Timestamp
对象上。如果是MonthEnd
这种加上Timestamp
,则第一次增量会将原日期向前滚动到符合频率规则的下一个日期。- 你可以通过
DateOffset.rollforward(time_stamp)
、DateOffset.rollback(time_stamp)
来显式地将日期向前或者向后滚动
-
-
利用
str(dt_obj)
函数或者datetime.strftime(format_str)
方法,可以将datetime
对象和Timestamp
对象格式化为字符串。而利用datetime.strptime(dt_str,format_str)
类方法,可以从字符串中创建日期。其中dt_str
为日期字符串,如'2011-11-12'
;format_str
为格式化字符串,如'%Y-%m-%d'
。-
datetime.strptime
是对已知格式进行日期解析的最佳方式。 - 对于一些常见的日期格式,使用
dateutil
这个第三方包中的parser.parse(dt_str)
,它几乎可以解析所有的日期表示形式。 -
pandas.to_datetime()
方法可以解析多种不同的日期表示形式,将字符串转换为日期。对于标准日期格式的解析非常快。如果发现无法解析(如不是一个日期),则返回一个NaT
(Not a Time
),它是时间戳数据中的NA
值。
-
-
Timedelta
对象:表示时间间隔。它等价于datetime.timedelta
类。pd.Timedelta(value=<object object at 0x00000000004BF340>, unit=None, **kwargs)
参数:
-
value
:一个Timedelta
对象,或者datetime.timedelta
,或者np.timedelta64
、或者一个整数,或者一个字符串。指定了时间间隔 -
unit
:一个字符串,指明了当输入时整数时,其单位。可以为'D'/'h'/'m'/'s'/'ms'/'us'/'ns'
-
days/seconds/microseconds/nanoseconds
:都是数值。给出了某个时间单位下的时间间隔
方法:
-
to_timedelta64()
:返回一个numpy.timedelta64
类型(按照纳秒的精度) -
total_seconds()
:返回总的时间间隔,单位秒(精度为纳秒) -
to_pytimedelta()
:返回一个datetime.timedelta
对象
属性:
-
components
:返回各成分的命名元组 -
days/seconds/microseconds/nanoseconds
:返回各个成分 -
delta
:返回总的时常(纳秒计)
一个时间间隔有天数、秒数等等属性。注意:所有的这些值与对应的单位相乘的和,才是总的时间间隔。
两个
Timestamp
相减可以得到时间间隔Timedelta
DateOffset
也一定程度上表示时间间隔,但是DateOffset
更侧重于按照某个固定的频率的间隔,比如一天、一个月、一周等。 -
3. 时间段 Period
-
Period
表示一个标准的时间段(如某年,某月)。时间段的长短由freq
属性决定。pd.Period(value=None, freq=None, ordinal=None, year=None, month=None,
quarter=None, day=None, hour=None, minute=None, second=None)
参数:
-
value
:一个Period
对象或者字符串(如'4Q2016'
),它表示一个时区段。默认为None
-
freq
:一个字符串,表示区间长度。可选的值从下面函数获取: pandas.tseries.frequencies._period_code_map.keys()
pandas.tseries.frequencies._period_alias_dictionary()
- 其他的参数和前面的其他类的构造函数类似。其中
quarter
表示季度。
属性:
-
day/dayofweek/dayofyear/hour/minute/quarter/second/
year/week/weekday/weekofyear/year
:对应的属性 -
end_time
:区间结束的Timestamp
。start_time
:区间开始的Timestamp
freq
方法:
-
.asfreq(freq,how)
:转换为其他区间。其中freq
为字符串。how
可以为'E'/'end'
,表示包含区间结束;'S'/'start'
表示包含区间开始。 -
.now(freq)
:返回当期日期对应freq
下的Period
-
strftime(format)
:给出Period
的格式化字符串表示 -
to_timestamp(freq,how)
:转换为Timestamp
。
-
-
pands
中的频率是由一个基础频率和一个倍数组成。- 基础频率通常以一个字符串别名表示,如
'M'
表示每月,'H'
表示每小时。 - 对于每个基础频率,都有一个
DateOffset
对象与之对应。如pandas.tseries.offsets
中的Hour/Minute
。Hour(4)
表示日期偏移为 4小时。 - 倍数为基础频率之前的数字,如
'4H'
。也可以组合多个频率4H30min
有些频率描述的时间点并不是均匀间隔的。如
'M'
就取决于每个月的天数。下面是一些常用的基础频率-
'D'
:偏移量类型为Day
,为每日历日 -
'B'
:偏移量类型为BusinessDay
,为每工作日 -
'H'
:偏移量类型为Hour
,为每小时 -
'T'
或者'min'
:偏移量类型为Minute
,为每分钟 -
'S'
:偏移量类型为Second
,为每秒 -
'L'
或者'ms'
:偏移量类型为Milli
,为每毫秒 -
'U'
:偏移量类型为Micro
,为每微秒 -
'M'
:偏移量类型为MonthEnd
,为每月最后一个日历日 -
'BM'
:偏移量类型为BusinessMonthEnd
,为每月最后一个工作日 -
'MS'
:偏移量类型为MonthBegin
,为每月第一个日历日 -
'BMS'
:偏移量类型为BusinessMonthBegin
,为每月第一个工作日 -
'W-Mon'...'W-TUE
:偏移量类型为Week
,为指定星期几(MON/TUE/WED/THU/FRI/SAT/SUN
)开始算起,每周
- 基础频率通常以一个字符串别名表示,如
-
调用
Timestamp
对象的.to_period(freq)
方法能将时间点转化为包含该时间点的时间段。 -
Period
的.asfreq()
方法可以实现时间段的频率转换。创建
Period
时,我们可以传入一个Timestamp
的各分量(由year/month...
等提供)。创建的Period
是包含该时刻,且指定频率。在使用Timestamp.to_period(freq)
也是如此。给定一个频率的
Period
,如果转换到更低频的Period
,则非常简单:返回指定频率下的包含本Period
的那个Period
即可。如果想转换到更高频的Period
,则由于在本Period
下,对应了很多个高频的Period
,则返回哪一个,由how
参数指定:-
how=S
:返回最开头的那个Period
-
how=E
:返回最末尾的那个Period
而
Period.to_timestamp(freq,how)
方法中,我们首先进行时间段的频率转换,然后提取该频率的Period
开始处的Timestamp
-
-
如果两个
Period
对象有相同的频率,则它们的差就是它们之间的单位数量。
4. DatetimeIndex
-
DatetimeIndex
是一种索引,它的各个标量值是Timestamp
对象,它用numpy
的datetime64
数据类型以纳秒形式存储时间戳。pd.DatetimeIndex(data=None, freq=None, start=None, end=None, periods=None,
copy=False, name=None, tz=None, verify_integrity=True, normalize=False,
closed=None, ambiguous='raise', dtype=None, **kwargs)
-
data
:一个array-like
对象,给出了各个时间 -
copy
:一个布尔值,如果为True
则拷贝基础数据 -
freq
:一个字符串或者DateOffset
对象,给出了频率 -
start
:一个datetime-like
,指定了起始时间。如果data=None
,则使用它来生成时间 -
periods
:一个整数(大于0),指定生成多少个时间。如果data=None
,则使用它来生成时间 -
end
:一个datetime-like
,指定了结束时间。如果data=None
且periods=None
,则使用它来生成时间 -
closed
:一个字符串或者None
。用于指示区间的类型。可以为'left'
(左闭右开),'right'
(左开右闭),None
(左闭右闭) -
tz
: 一个字符串,指定了时区。如果非空,则返回的是localized DatetimeIndex
-
name
:指定了Index
的名字
-
-
pandas.date_range()
函数可以生成指定长度的DatetimeIndex
pandas.date_range(start=None, end=None, periods=None, freq='D', tz=None,
normalize=False,name=None, closed=None, **kwargs)
各参数意义参考
DatetimeIndex
的构造函数。 -
对于以
DatetimeIndex
为索引的Series
,我们可以通过指定Timestamp
切片来截取指定时间区间的数据(也可以是对应的字符串来指定Timestamp
)。注意:这里的Timestamp
可以并不是DatetimeIndex
的key
。 -
DatetimeIndex
的方法有:(DatetimeIndex
继承自Index
,因此它有Index
的所有方法)-
indexer_at_time(time, asof=False)
:返回指定time
的位置 -
indexer_between_time( start_time, end_time, include_start=True,
include_end=True)
:返回指定的两个时间之间的索引的位置 -
normalize()
:将时间调整到午夜 -
to_period( freq=None)
:以指定freq
转换到PeriodIndex
-
to_perioddelta( freq)
:计算不同索引值的Timedelta
,然后转换成一个TimedeldaIndex
-
to_pydatetime
/tz_convert
/tz_localize
:对每个时间使用Timestamp
对应的方法
任何
Timestamp
的属性都可以作用于DatetimeIndex
。 -
5. PeriodIndex
-
如果将一个
Period
序列作为索引,则该索引就是PeriodIndex
类型。其各位置的值为Period
对象。pd.PeriodIndex(data=None, ordinal=None, freq=None, start=None, end=None,
periods=None, copy=False, name=None, tz=None, dtype=None, **kwargs)
-
data
:一个array-like
对象,给出了各个时间段 -
copy
:一个布尔值,如果为True
则拷贝基础数据 -
freq
:一个字符串或者period
对象,给出了频率 -
start
:一个period-like
,指定了起始时间段。如果data=None
,则使用它来生成时间段 -
periods
:一个整数(大于0),指定生成多少个时间段。如果data=None
,则使用它来生成时间段 -
end
:一个period-like
,指定了结束时间段。如果data=None
且periods=None
,则使用它来生成时间段 -
year/month/quarter/day/hour/minute/second
:一个整数、array
或者Series
。通过它们可以组装出一个Period
序列。 -
tz
: 一个字符串,指定了时区。如果非空,则返回的是localized DatetimeIndex
-
name
:指定了Index
的名字
-
-
pandas.period_range()
函数可以生成指定长度的PeriodIndex
pd.period_range(start=None, end=None, periods=None, freq='D', name=None)
参数意义参见
PeriodIndex
的构造函数。 -
PeriodIndex
的方法有:(PeriodIndex
继承自Index
,因此它有Index
的所有方法)-
asfreq( freq=None, how='E')
:转换成另一种频率的时间段 -
to_timestamp(self, freq=None, how='start')
:转成DatetimeIndex
-
tz_convert(self, tz)/tz_localize(self, tz, infer_dst=False)
:转成对应时区的DatetimeIndex
任何
Period
的属性都可以作用于PeriodIndex
。 -
6. resample 和频率转换
-
Series/DataFrame
有一个shift()
方法用于执行单纯的前移或者后移操作,:Series/DataFrame.shift(periods=1, freq=None, axis=0)
-
periods
:一个整数(可以为负的),指定移动的数量。对于时间序列,单位由freq
指定。 -
freq
:一个DateOffset/timedelta
或者一个频率字符串。指定移动的单位。注意,如果为PeriodIndex
,则freq
必须和它匹配。 -
axis
:为0/'index'
表示沿着0轴移动;为1/'columns'
表示沿着1轴移动
如果为时间序列,则该方法移动并建立一个新的索引,但是
Series/DataFrame
的值不变。对于非时间序列,则保持索引不变,而移动Series/DataFrame
的值。本质上,时间序列和非时间序列都是
index_i-->value_i
转换成index_i+n-->value_i
。只是时间序列截取的都是有效值,非时间序列截取了NaN
而已。 -
-
重采样
resampling
指的是将时间序列从一个频率转换到另一个频率的处理过程。- 将高频数据转换到低频数据称作降采样。降采样时,待聚合的数据不必拥有固定的频率,期望的频率(低频的)会自动划分聚合的
bin
的边界。这些bin
将时间序列拆分为多个片段。这些片段都是半开放的,一个数据点只能属于一个片段,所有的片段的并集组成了整个时间帧。在对数据降采样时,只需要考虑两样: - 各个区间哪边是闭合的
- 如何标记各个聚合
bin
,用区间的开头还是结尾 - 将低频数据转换到高频数据称作升采样。将数据转换到高频时,就不需要聚合了,而是插值,默认引入缺失值。插值的填充和填充方式与
fillna/reindex
的一样。 - 在对时间段
Period
进行重采样时,升采样稍微麻烦点,因为你必须决定:哪个高频区间代表原区间。就像asfreq
一样,convention
可以设置为'end'/'start'
有些重采样并不划分到上述两者之中。比如将
W-WED
(每周三)转换到W-FRI
(每周五)。另外,由于Period
是时间区间,所以升采样和降采样的规则就比较严格:- 降采样中,目标频率必须包含原频率。如
Day->Month
,目标频率为每月,原频率为每天。 - 升采样中,原频率必须包含目标频率。如
Day->Hour
,目标频率为每小时,原频率为每天。
如果不满足这些条件,则会引发异常。
- 将高频数据转换到低频数据称作降采样。降采样时,待聚合的数据不必拥有固定的频率,期望的频率(低频的)会自动划分聚合的
-
resample
方法:Series/DataFrame.resample(rule, how=None, axis=0, fill_method=None, closed=None,
label=None, convention='start', kind=None, loffset=None, limit=None,
base=0, on=None, level=None)
-
rule
:一个字符串,指定了重采样的目标频率 -
axis
:为0/'index'
表示沿着0轴重采样;为1/'columns'
表示沿着1轴重采样 -
closed
:一个字符串,指定降采样中,各时间段的哪一端是闭合的。如果为'right'
,则是左开右闭区间;如果为'left'
,则是左闭右开区间 -
label
:在降采样中,如何设置聚合值的标签。可以为'right'/'left'
(面元的右边界或者左边界)。如:9:30~9:35
这5分钟会被标记为9:30
或者9:35
-
how
:用于产生聚合值的函数名或者数组函数。可以为'mean'/'ohlc'/np.max
等。默认为'mean'
,其他常用的有:'first'/'last'/'median'/'ohlc'/'max'/'min'
。how
被废弃了,而是采用.resample().mean()
这种方案。 -
convention
:当重采样时期时,将低频转换到高频所采用的约定。可以为's'/'start'
(用第一个高频)或者'e'/'end'
(用最后一个高频) -
loffset
:一个timedelta
,用于调整面元(bin
)标签。如'-1s'
,会将用于将聚合的结果标签调早1秒,从而更容易表示它代表哪个区间。比如12:00:00
你就难以判别是哪个区间,而11:59:59
就很容易知道它是那个区间。你也可以对调用结果对象使用
.shift()
方法来实现该目的,这样就不必设置loffset
了 -
base
:一个整数,默认为0.用于聚合过程中,当频率可以整除1D
(比如4H
)时,第一个完整的分组从哪个元素开始的。如rule='4H'
,base=2
,则Series[0:1]
作为一个分组,Series[2:6]....
作为一个分组.... -
on
:一个字符串,对于DataFrame
,它指定了重采样的列。该列必须是datetime-like
-
level
:一个字符串或者整数。对于MultiIndex
,该参数指定了被重采样的子索引 -
fill_method
:一个字符串,指定升采样时,如何插值。如'ffill'/'bfill'
。默认不插值该参数被废弃。推荐使用
.resample().ffill()
这种方案。而limit
作为ffill()
的参数。 -
limit
:一个整数。指定向前或者向后填充时,运行连续填充的最大单元数量 -
kind
:一个字符串,指定聚合到时间段Period
还是时间戳Timestamp
。默认聚合到时间序列的索引类型
-
-
OHLC
重采样是计算bin
中的四个值:开盘值(第一个值)、收盘值(最后一个值)、最高值(最大值)、最低值(最小值) -
另一种降采样的办法是:使用
groupby
功能。如:series.groupby(lambda x:x.month).mean()
如果你想根据年份来聚合,则使用
x.year
。
十、 DataFrame 绘图
-
matplotlib
是一种比较低级的工具,pandas
中有许多利用DataFrame
对象数据组织特点来创建标准图表的高级绘图方法。 -
Series/DataFrame.plot()
:绘制图形。Series.plot(kind='line', ax=None, figsize=None, use_index=True, title=None, grid=None,
legend=False, style=None, logx=False, logy=False,loglog=False,xticks=None,yticks=None,
xlim=None, ylim=None, rot=None, fontsize=None, colormap=None, table=False, yerr=None,
xerr=None, label=None, secondary_y=False, **kwds)
DataFrame.plot(x=None, y=None, kind='line', ax=None, subplots=False, sharex=None,
sharey=False, layout=None, figsize=None, use_index=True, title=None, grid=None,
legend=True, style=None, logx=False, logy=False, loglog=False, xticks=None,
yticks=None, xlim=None, ylim=None, rot=None, fontsize=None, colormap=None,
table=False, yerr=None, xerr=None, secondary_y=False, sort_columns=False, **kwds)
-
kind
:绘制的类型。可以为:'line'
、'bar'
、'barh'
(水平的bar
)、'hist'
、'box'
、'kde'
(核密度估计)、'density'
(类似kde
)、'area'
、'pie'
-
ax
:一个Axes
实例对象。如果为空,则是plt.gca()
的返回值(当前Axes
) -
figsize
:一个元组,指定图片大小(单位为英寸) -
use_index
:一个布尔值。如果为True
,则使用index
作为X
轴。 -
title
:图形的标题 -
grid
:一个布尔值。如果为True
,则开启网格 -
legend
:一个布尔值,如果为True
,则放置图例 -
style
:一个列表或者字典,给出了每一列的线型 -
logx
:一个布尔值,如果为True
,则x
轴为对数型 -
logy
:一个布尔值,如果为True
,则y
轴为对数型 -
loglog
:一个布尔值,如果为True
,则x
轴和y
轴都为对数型 -
xticks
:一个序列,用于给出xticks
-
yticks
:一个序列,用于给出yticks
-
xlim
:一个二元的元组或者序列,给出x
轴范围 -
ylim
:一个二元的元组或者序列,给出y
轴范围 -
rot
:一个整数,给出了x
轴和y
轴tick
旋转角度(不是弧度)。 -
fontsize
:一个整数,给出了xtick/ytick
的字体大小 -
colormap
:一个字符串或者colormap
对象,给出了colormap
-
colorbar
:一个布尔值。如果为True
,则绘制colorbar
(只用于scatter
和hexbin
图中) -
position
:一个浮点数。给出了bar
图中,各bar
的对其位置(0表示bar
的左侧与它的坐标 对其;1表示bar
的右侧与它的坐标对其) -
layout
:一个元组。给出了(rows,columns)
-
table
:一个布尔值或者Series/DataFrame
。如果为True
,则将本Series/DataFrame
绘制为一个表格;如果为Series/DataFrame
,则将该参数绘制为表格 -
yerr
:用于绘制Error Bar
-
xerr
:用于绘制Error Bar
-
label
:plot
的label
参数 -
secondary_y
:一个布尔值或者一个整数序列。如果为True
,则y
轴绘制在右侧 -
mark_right
:一个布尔值,如果为True
且secondary_y=True
,则在图例中标记为right
-
kwds
:传递给matplotlib
中的plot
函数的其他关键字参数
在
DataFrame.plot
中,下面的参数意义为:-
x
:label
或者position
-
y
:label
或者position
-
subplots
:一个布尔值,如果为True
,则将每一列作为一个子图来绘制 -
sharex
:一个布尔值。如果为True
,且subplots=True
,则子图共享x
轴 -
sharey
:一个布尔值。如果为True
,且subplots=True
,则子图共享y
轴 -
stacked
:一个布尔值。在bar
中,如果为True
,则将柱状图堆积起来 -
sort_columns
:一个布尔值。如果为True
,则根据列名来决定绘制的先后顺序。
它们返回的是
AxesSubplot
对象,或者AxesSubplot
的ndarray
-
-
给出一组序列,我们可以手工绘制每个序列的散布图,以及各自的核密度估计。我们可以使用
scatter_matrix
函数:pandas.tools.plotting.scatter_matrix(frame, alpha=0.5, figsize=None, ax=None,
grid=False, diagonal='hist', marker='.', density_kwds=None, hist_kwds=None,
range_padding=0.05, **kwds)
-
frame
:为DataFrame
对象 -
diagonal
:选择对角线上的图形类型。可以为'hist'/'kde'
-
hist_kwds
:绘制hist
的参数 -
density_kwds
:绘制kde
的参数 -
range_padding
:一个浮点数,用于延伸x/y
轴的范围。如果它为0.1
,表示x
轴延伸x_max-xmin
的0.1倍 每一个子图是这样生成的:以DataFrame
中某一列为横坐标,另一列为纵坐标生成的散点图。
-
十二、 数据加载和保存
1. 文本文件
-
read_csv
可以读取文本文件(.csv
格式):pandas.read_csv(filepath_or_buffer, sep=', ', delimiter=None, header='infer',
names=None, index_col=None, usecols=None, squeeze=False, prefix=None,
mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None,
false_values=None, skipinitialspace=False,skiprows=None, nrows=None,na_values=None,
keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True,
parse_dates=False, infer_datetime_format=False,keep_date_col=False,date_parser=None,
dayfirst=False, iterator=False, chunksize=None, compression='infer', thousands=None,
decimal='.', lineterminator=None, quotechar='"', quoting=0, escapechar=None,
comment=None, encoding=None, dialect=None, tupleize_cols=False,
error_bad_lines=True, warn_bad_lines=True, skipfooter=0, skip_footer=0,
doublequote=True, delim_whitespace=False, as_recarray=False,
compact_ints=False, use_unsigned=False, low_memory=True,
buffer_lines=None, memory_map=False, float_precision=None)
-
filepath_or_buffer
:一个字符串,或者一个pathlib.Path
对象,或者任何拥有.read()
方法的对象。它指定了被解析的文件的位置。如果是个字符串,则必须是个URL
(其中包含了协议名,如http//,ftp//,file//
等) -
sep
:一个字符串,指定了分隔符。默认为','
。如果设定为None
,则自动决议分隔符。- 如果字符串长度大于1,则自动解析为正则表达式。如
'\s+\
解析为空白符
- 如果字符串长度大于1,则自动解析为正则表达式。如
-
delimiter
:一个字符串,指定了分隔符。它是sep
参数的另一个候选参数 -
delim_whitespace
:一个布尔值。如果为True
,则将空白符(连续的空白或者单个空白)作为分隔符。此时不需要提供delimiter
参数。它等价于sep='\s+'
-
header
:一个整数或者整数列表。它指定了那些行是标题行,0表示第一行。如果你指定了header=[1,3,5]
,则第三行(行id=2
)和第五行(行id=4
)被忽略(不被解析)。- 如果
names
参数为空,则header
默认值为 0.如果names
参数提供了,则header
默认值为None
- 如果
-
- 该参数会忽略注释行。 - 如果`skip_blank_lines=True`,则该参数会忽略空白行。因此`header=0`表示第一个有效的数据行
-
names
:一个array-like
。它给出了列名。- 如果文件不包含标题行,则你需要显式通过
names
传入列名 - 如果
mangle_dupe_cols=True
,则可以传入重复的列名。否则不允许重复列名
- 如果文件不包含标题行,则你需要显式通过
-
index_col
:一个整数,或者序列,或者False
。它指定哪一列作为row labels
。如果你指定了一个序列,则使用MultiIndex
。如果为False
,则不采用任何列作为row labels
-
usecols
:一个array-like
。它指定:你将采用哪些列来组装DataFrame
。该参数各元素必须要么是代表位置的整数,要么是代表列名的字符串 -
as_recarray
:一个布尔值。被废弃的参数。 -
squeeze
:一个布尔值。如果为True
,则当解析结果只有一列数据时,返回一个Series
而不是DataFrame
-
prefix
:一个字符串。当没有标题时,你可以提供这个参数来给列名加一个前缀。(如果不加前缀,则列名就是0,1,2...
) -
mangle_dupe_cols
:一个布尔值。如果为True
,则重复的列名X,X...
被修改为X.0,X.1,...
。如果为False
,则重复的列名这样处理:后面的覆盖前面的 -
dtype
:一个Type name
或者字典:column->type
。它可以给出每个列的类型。 -
engine
:一个字符串,指定用什么解析引擎。可以为'c'/'python'
。c
更快,但是python
拥有更多特性 -
converters
:一个字典,给出了每一列的转换函数。字典的键为代表列的位置的整数,或者代表列的名字的字符串。字典的值为可调用对象,参数为一个标量(就是每个元素值) -
true_values
:一个列表,给出了哪些值被认为是True
-
false_values
:一个列表,给出了哪些值被认为是False
-
skipinitialspace
:一个布尔值。如果为True
,则跳过分隔符之后的空白符 -
skiprows
:一个array-like
或者整数。如果为序列,则指定跳过哪些行(从0计数);如果为整数,则指定跳过文件开头的多少行。注意:空行和注释行也包括在内,这一点和header
不同。 -
skipfooter
:一个整数。指定跳过文件结尾的多少行。不支持engine='c'
-
skip_footer
:被废弃的参数 -
nrows
:一个整数。指定读取多少行。 -
na_values
:一个标量、字符串、字典、列表。指定哪些被识别为NAN
。默认的NAN
为列表['nan','NAN','NULL'....]
-
keep_default_na
:一个布尔值。如果为True
,则当你指定了na_values
时,默认的NAN
被追加到na_values
上;否则指定的na_values
代替了默认的NAN
-
na_filter
:一个布尔值。如果为True
,则不检查NaN
,此时解析速度大大加快(但是要求你的数据确实没有NAN
) -
verbose
:一个布尔值。如果为True
,输出解析日志 -
skip_blank_lines
:一个布尔值。如果为True
,则跳过空白行,而不是解析为NaN
-
parse_dates
:一个布尔值、整数列表、标签列表、或者list of list or dict
。对于iso8601
格式的日期字符串,解析速度很快。- 如果为布尔值:如果为
True
,则解析index
为日期 - 如果为整数列表或者标签列表,则解析对应的列为日期
- 如果列表的列表,如
[[1,3]]
,则将列1和列3组合在一起,解析成一个单独的日期列 - 如果为字典,如
{'aaa':[1,3]}
,则将列1和列3组合在一起,解析成一个单独的日期列,日期列的名字为'aaa'
。
- 如果为布尔值:如果为
-
infer_datetime_format
:一个布尔值。如果为True
,且parse_dates
非空,则pandas
试图从数据中推断日期格式。 -
keep_date_col
:一个布尔值。如果为True
,并且parse_dates
使用多个列合成一列日期,则保留原有的列 -
date_parser
:一个函数对象。它将一列字符串转换成一列日期。 -
dayfirse
:一个字符串。如果为True
,则日期格式为DD/MM
-
iterator
:一个布尔值。如果为True
,则返回一个TextFileReader
对象,该对象可以用于迭代或者.get_chunk()
来返回数据块 -
chunksize
:一个整数。指定TextFileReader
对象.get_chunk()
返回的数据块的大小。 -
compression
:一个字符串。可以为'infer','gzip','bz2','zip','xz',None
。如果文件为压缩文件,则它用于指定解压格式 -
thousands
:一个字符串。指定了数值中千位数的分隔符,如999,999,999
-
decimal
:一个字符串,指定了小数点的分隔符,如9.999
-
float_precision
:一个字符串。指定了C engine
的转换浮点数的精度。None
普通转换,'high'
为高精度转换,'round_trip'
为round_trip
转换。 -
lineterminator
:一个长度为1的字符串。指定了C engine
中的换行符 -
quotechar
:一个长度为1的字符串,它指定了引用字符。比如"aaa,bbb"
,这种数据是引用数据。如果你用,
分隔,则有问题。在引用字符包围的数据中,不考虑分隔符。 -
comment
:一个长度为1的字符串,指定了注释字符。如果该字符串出现在行中,则行末的字符不被解析。如果该字符串出现在行首,则本行不被就解析。 -
encoding
:一个字符串,指定了编码类型 -
error_bad_lines
:一个布尔值。如果为True
,则如果某一行有太多字段,则函数抛出异常。如果为False
,则抛弃该行,顺利解析。只用于C engine
-
warn_bad_lines
:一个布尔值。如果为True
,且error_bad_lines=False
,则对于异常的行,输出警告 -
buffer_lines/compact_ints /use_unsigned
:被废弃的参数 -
memory_map
:如果为True
,且filepath
是一个文件名,则使用内存映射,将文件映射到内存中。
-
read_table
也能完成read_csv
的功能。二者接口一致。pandas.read_table(filepath_or_buffer, sep='\t', delimiter=None, header='infer',
names=None, index_col=None, usecols=None, squeeze=False, prefix=None,
mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None,
false_values=None, skipinitialspace=False,skiprows=None, nrows=None, na_values=None,
keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True,
parse_dates=False,infer_datetime_format=False,keep_date_col=False, date_parser=None,
dayfirst=False, iterator=False, chunksize=None, compression='infer', thousands=None,
decimal='.', lineterminator=None, quotechar='"', quoting=0, escapechar=None,
comment=None, encoding=None, dialect=None, tupleize_cols=False,
error_bad_lines=True, warn_bad_lines=True, skipfooter=0, skip_footer=0,
doublequote=True, delim_whitespace=False, as_recarray=False,
compact_ints=False, use_unsigned=False, low_memory=True,
buffer_lines=None, memory_map=False, float_precision=None)
-
DataFrame/Series.to_csv
方法可以将数据写入到文件中DataFrame.to_csv(path_or_buf=None, sep=', ', na_rep='', float_format=None,
columns=None, header=True, index=True, index_label=None, mode='w',
encoding=None, compression=None, quoting=None, quotechar='"',
line_terminator='\n', chunksize=None, tupleize_cols=False, date_format=None,
doublequote=True, escapechar=None, decimal='.')
Series.to_csv(path=None, index=True, sep=', ', na_rep='', float_format=None,
header=False, index_label=None, mode='w', encoding=None, date_format=None,
decimal='.')
-
path_or_buf
:一个字符串或者file
对象。指定写入的文件。如果为空,则返回一个字符串而不是写入文件 -
sep
:一个字符串,指定字段的分隔符 -
na_rep
:一个字符串,指定NaN
的代表字符串 -
float_format
:一个字符串,指定了浮点数的格式化字符串 -
columns
:一个序列,指定要写入哪些列 -
header
:一个布尔值或者字符串列表。如果为True
,则写出列名。如果为字符串列表,则它直接指定了列名的别名 -
index
:一个布尔值。如果为True
,则输出index label
-
mode
:一个字符串,文件操作的读写模式。默认为'w'
-
encoding
:一个字符串,指定编码方式 -
compression
:一个字符串,指定压缩格式 -
line_terminator
:一个字符串,指定换行符 -
chunksize
:一个整数,指定了一次写入多少行 -
date_format
:一个字符串,给出了日期格式化字符串 -
decimal
:一个字符串,给出了小数点的格式 -
tupleize_cols
:一个布尔值。如果为True
,则MultiIndex
被写成list of tuples
-
2. Json
-
read_json
能够读取Json
文件:pandas.read_json(path_or_buf=None, orient=None, typ='frame', dtype=True,
convert_axes=True, convert_dates=True, keep_default_dates=True, numpy=False,
precise_float=False, date_unit=None, encoding=None, lines=False)
-
path_or_buf
:一个字符串或者一个file-like
对象。如果是个字符串,则必须是个URL
(其中包含了协议名,如http//,ftp//,file//
等) -
orient
:一个字符串,指定了期望的JSON
格式。可选的格式有(参考to_json
的实例): -
'split'
:JSON
是个类似字典的格式:{index -> [index], columns -> [columns], data -> [values]}
-
'records'
:JSON
是个类似列表的格式:[{column -> value}, ... , {column -> value}]
-
'index'
:JSON
是个类似字典的格式{index -> {column -> value}}
-
'columns'
:JSON
是个类似字典的格式{column -> {index -> value}}
-
'values'
:JSON
就是值的序列
注意:如果
type=='series'
,则允许的'orients= {'split','records','index'}
,默认为'index'
,且如果为'index'
,则要求索引为唯一的。如果type=='frame'
,则允许上所有的格式,默认为'columns'
,且如果为'index'/'columns'
,则要求DataFrame.index
为唯一的;如果'index'/'columns'/'records'
,则要求DataFrame.columns
为唯一的-
typ
:一个字符串,指定将JSON
转换为Series/DataFrame
那一种。可以为'series'
,'frame'
-
dtype
:一个布尔值或者字典。如果为True
,则自动推断数值类型。如果为False
,则不推断类型。如果为字典,则给出了每一列的数值类型 -
convert_axes
:一个布尔值,如果为True
,则试图转换到合适的数值类型 -
convert_dates
:一个布尔值,如果为True
,则试图转换日期列为日期。它转换下面这些列名的列:列名以'_at'/'_time'
结束、列名以'timestamp'
开始、列名为'mofified'/'date'
-
keep_default_dates
:一个布尔值。如果为True
,则当转换日期列时,保留原列 -
numpy
:一个布尔值,如果为True
,则直接转换为ndarray
-
precise_float
:一个布尔值,如果为True
,则使用解析为更高精度的浮点数 -
date_unit
:一个字符串。用于转换时间戳到日期。它提供时间戳的单位,如's'/'ms'
-
lines
:一个布尔值。如果为True
,则读取文件的每一行作为一个JSON
-encoding
:一个字符串,指定编码方式
-
-
将
pandas
对象保存成JSON
:Series/DataFrame.to_json(path_or_buf=None, orient=None, date_format='epoch',
double_precision=10, force_ascii=True, date_unit='ms', default_handler=None,
lines=False)
-
path_or_buf
:指定保存的地方。如果为None
,则该函数返回一个StringIO
对象 -
orient
参数:参考read_json()
-
date_format
:一个字符串,指定日期转换格式。可以为'epoch'
(从1970-1-1
日以来的毫秒数)、'iso'
-
double_precision
:一个整数,指定了浮点数的精度 -
force_ascii
:一个布尔值,如果为True
,则将encoded string
转换成ASCII
-
date_unit
:一个字符串,参考read_json
-
default_handler
:一个可调用对象。用于处理当对象无法转换成JSON
的情况。它只有一个参数,就是被转换的对象 -
lines
:一个布尔值。如果orient='records'
时,输出换行符。对其他格式则抛出异常
-
3. 二进制文件
-
pandas.read_pickle(path)
可以从pickle
文件中读取数据,path
为pickle
文件的文件名。Series/DataFrame.to_pickle(path)
:将Series/DataFrame
保存到pickle
文件中,path
为pickle
文件的文件名。
4. Excel 文件
-
read_excel
读取Excel
文件。需要用到第三方包xlrd/xlwt
,前者读excel
,后者写excel
pandas.read_excel(io, sheetname=0, header=0, skiprows=None, skip_footer=0,
index_col=None, names=None, parse_cols=None, parse_dates=False, date_parser=None,
na_values=None, thousands=None, convert_float=True, has_index_names=None,
converters=None, true_values=None, false_values=None, engine=None,
squeeze=False, **kwds)
-
io
:一个字符串,或者file-like
对象。如果是个字符串,则必须是个URL
(其中包含了协议名,如http//,ftp//,file//
等) -
sheetname
:一个字符串或者整数,或者列表。它指定选取Excel
文件中哪个sheet
。字符串指定的是sheet
名,整数指定的是sheet
的位置(0为第一个sheet
) -
engine
:一个字符串,指定了读写Excel
的引擎。可以为:io.excel.xlsx.writer
、io.excel.xls.writer
、io.excel.xlsm.writer
、 - 其他参数参考
read_csv
-
-
保存
DataFrame
到Excel
文件:DataFrame.to_excel(excel_writer, sheet_name='Sheet1', na_rep='',
float_format=None, columns=None, header=True, index=True, index_label=None,
startrow=0, startcol=0, engine=None, merge_cells=True, encoding=None,
inf_rep='inf', verbose=True)
-
excel_writer
:一个字符串(文件名)或者一个ExcelWriter
对象 -
sheet_name
:一个字符串,指定sheet
名 -
na_rep
:一个字符串,代表NaN
-
startrow/startcol
:指定了左上角的单元格的位置 -
engine
:一个字符串,指定了读写Excel
的引擎。可以为:io.excel.xlsx.writer
、io.excel.xls.writer
、io.excel.xlsm.writer
、 -
merge_cells
:一个布尔值。如果为True
,则多级索引中,某些索引会合并单元格 -
inf_rep
:一个字符串,只代表无穷大。
-
5. HTML 表格
-
read_html
可以将HTML
中的<table></table>
解析为一个DataFrame
列表。pandas.read_html(io, match='.+', flavor=None, header=None, index_col=None,
skiprows=None, attrs=None, parse_dates=False, tupleize_cols=False,
thousands=', ', encoding=None, decimal='.', converters=None,
na_values=None, keep_default_na=True)
-
io
:为一个字符串或者一个file-like
对象。 -
match
:一个字符串或者正则表达式。HTML
中的<table></table>
中,只要匹配这个正则表达式的表格都被处理。默认的为匹配任何非空的表格 -
flavor
:一个字符串,指定了解析引擎。可以为'bs4'
或者'html5lib'
或者'lxml'
-
attrs
:一个字典。它筛选出你要解析哪些表格 - 其他参数参考
read_csv
-
-
可以通过
DataFrame.to_html()
转换为HTML
的表格:DataFrame.to_html(buf=None, columns=None, col_space=None, header=True,
index=True, na_rep='NaN', formatters=None, float_format=None,
sparsify=None, index_names=True, justify=None, bold_rows=True,
classes=None, escape=True, max_rows=None, max_cols=None, show_dimensions=False,
notebook=False, decimal='.', border=None)
-
bold_rows
:一个布尔值。如果为True
,则让row label
加粗 -
classes
:一个字符串或者列表或者元组,给出了table
的css class
-
escape
:一个布尔值,如果为True
,则将字符<>&
为安全的HTML
字符 -
max_rows
:一个整数,指定最大输出行数。默认显示全部的行 -
decimal
:一个字符串,指定了小数点的格式 -
border
:一个整数,给出了border
属性的值。 -
buf
:指定将HTML
写到哪里,它是一个StringIO-like
对象 -
col_space
:一个整数,给出每一列最小宽度 -
header
:一个布尔值,如果为True
,则打印列名 -
columns
:一个序列,指定要输出哪些列 -
index
:一个布尔值,如果为True
,则打印index labels
-
formatters
:一个一元函数的列表,或者一元函数的字典。给出了每一列的转换成字符串的函数 -
float_format
:一个一元函数,给出了浮点数转换成字符串的函数 -
justify
:左对齐还是右对齐。可以为'left'
/'right'
-
6. SQL
-
read_sql_table
从指定数据表中,提取你所需要的列。pandas.read_sql_table(table_name, con, schema=None, index_col=None,
coerce_float=True, parse_dates=None, columns=None, chunksize=None)
-
table_name
:一个字符串,指定了数据库的表名 -
con
:一个SQLAlchemy conectable
或者一个database string URI
,指定了连接对象它就是SQLAlchemy
中的Engine
对象。 -
schema
:一个字符串,给出了SQL schema
(在mysql
中就是database
) -
index_col
:一个字符串或者字符串列表,指定哪一列或者哪些列作为index
-
coerce_float
:一个布尔值,如果为True
,则试图转换结果到数值类型 -
parse_dates
:一个列表或者字典。指定如何解析日期:- 列名的列表:这些列将被解析为日期
- 字典
{col_name:format_str}
:给出了那些列被解析为日期,以及解析字符串 - 字典
{col_name:arg dict}
:给出了哪些列被解析为日期,arg dict
将传递给pandas.to_datetime()
函数来解析日期
-
columns
:一个列表,给出了将从sql
中提取哪些列 -
chunksize
:一个整数。如果给出了,则函数返回的是一个迭代器,每次迭代时,返回chunksize
行的数据。
-
-
read_sql_query
可以选择select query
语句。因此你可以执行多表联合查询。pandas.read_sql_query(sql, con, index_col=None, coerce_float=True,
params=None, parse_dates=None, chunksize=None)
-
sql
:一个SQL
查询字符串,或者SQLAlchemy Selectable
对象。 -
params
:一个列表,元组或者字典。用于传递给sql
查询语句。比如:sql
为uses %(name)s...
,因此params
为{'name':'xxxx'}
- 其他参数见
read_sql_table
-
-
read_sql
是前两者的一个包装,它可以根据sql
参数,*地选择使用哪个方式。pandas.read_sql(sql, con, index_col=None, coerce_float=True, params=None,
parse_dates=None, columns=None, chunksize=None)
-
sql
:一个数据表名,或者查询字符串,或者SQLAlchemy Selectable
对象。如果为表名,则使用read_sql_table
;如果为后两者,则使用read_sql_query
-
-
pandas
对象的.to_sql()
方法用于插入数据库。Series/DataFrame.to_sql(name, con, flavor=None, schema=None, if_exists='fail',
index=True, index_label=None, chunksize=None, dtype=None)
-
name
:一个字符串,指定表名 -
con
:一个SQLAlchemy conectable
或者一个database string URI
,指定了连接对象。它就是SQLAlchemy
中的Engine
对象。 -
flavor
:被废弃的参数 -
schema
:一个字符串,指定了SQL schema
-
if_exists
:一个字符串,指定当数据表已存在时如何。可以为: -
'fail'
:什么都不做(即不存储数据) -
'replace'
:删除数据表,创建新表,然后插入数据 -
'append'
:如果数据表不存在则创建数据表然后插入数据。入股数据表已存在,则追加数据 -
index
:一个布尔值。如果为True
,则将index
作为一列数据插入数据库 -
index_label
:index
的存储名。如果index=True
,且index_label=None
,则使用index.name
-
chunksize
:一个整数。 如果为None
,则一次写入所有的记录。如果非空,则一次写入chunksize
大小的记录 -
dtype
:一个字典。给出了各列的存储类型。
-