Pandas API参考

本文为谷歌翻译,有些翻译不准确 请参考原文档

http://pandas.pydata.org/pandas-docs/stable/api.html

此页面概述了所有公共pandas对象，函数和方法。 pandas。* namespace中公开的所有类和函数都是公共的。

一些子包是公共的，包括pandas.errors，pandas.plotting和pandas.testing。 文档中提到了pandas.io和pandas.tseries子模块中的公共函数。 pandas.api.types子包包含一些与pandas中的数据类型相关的公共函数。

Pickling

read_pickle(path[,compression])   从文件加载pickled pandas对象（或任何对象）。

Flat File

read_table(filepath_or_buffer[, sep, …])	将常规分隔文件读入DataFrame
read_csv(filepath_or_buffer[, sep, …])	将CSV（逗号分隔）文件读入DataFrame
read_fwf(filepath_or_buffer[, colspecs, widths])	将固定宽度格式化的行表读入DataFrame
read_msgpack(path_or_buf[, encoding, iterator])	从指定的文件路径加载msgpack pandas对象

Clipboard

read_clipboard([sep])	从剪贴板中读取文本并传递给read_table

Excel

read_excel(io[, sheet_name, header, names, …])	将Excel表读入pandas DataFrame
ExcelFile.parse([sheet_name, header, names, …])	将指定的工作表解析为DataFrame

JSON

read_json([path_or_buf, orient, typ, dtype, …])	将JSON字符串转换为pandas对象
json_normalize(data[, record_path, meta, …])	将“半结构化JSON数据”“规范化”为平面表
build_table_schema(data[, index, …])	从数据创建表模式。

HTML¶

read_html(io[, match, flavor, header, …])	将HTML表读入DataFrame对象列表。

HDFStore: PyTables (HDF5)

read_hdf(path_or_buf[, key, mode])	从商店读取，如果我们打开它关闭它。
HDFStore.put(key, value[, format, append])	将对象存储在HDFStore中
HDFStore.append(key, value[, format, …])	附加到文件中的表。
HDFStore.get(key)	检索存储在文件中的pandas对象
HDFStore.select(key[, where, start, stop, …])	检索存储在文件中的pandas对象，可选择基于where条件
HDFStore.info()	打印详细信息
HDFStore.keys()	返回与HDFStore中存储的对象相对应的键（可能无序）列表。

Feather

read_feather(path[, nthreads])	从文件路径加载羽毛格式对象

Parquet

read_parquet(path[, engine, columns])	从文件路径加载镶木地板对象，返回DataFrame。

SAS

read_sas(filepath_or_buffer[, format, …])	读取存储为XPORT或SAS7BDAT格式文件的SAS文件。

SQL

read_sql_table(table_name, con[, schema, …])	将SQL数据库表读入DataFrame。
read_sql_query(sql, con[, index_col, …])	将SQL查询读入DataFrame。
read_sql(sql, con[, index_col, …])	将SQL查询或数据库表读入DataFrame。

Google BigQuery

read_gbq(query[, project_id, index_col, …])	从Google BigQuery加载数据。

STATA

read_stata(filepath_or_buffer[, …])	将Stata文件读入DataFrame。
StataReader.data(**kwargs)	（已弃用）从Stata文件中读取观察结果，将其转换为数据帧
StataReader.data_label()	返回Stata文件的数据标签
StataReader.value_labels()	返回一个dict，将每个变量名称与一个dict相关联，将每个值与其对应的标签相关联
StataReader.variable_labels()	将变量标签作为dict返回，将每个变量名称与相应的标签相关联
StataWriter.write_file()	

General functions¶

Data manipulations

melt(frame[, id_vars, value_vars, var_name, …])	“Unpivots”DataFrame从宽格式到长格式，可选择设置标识符变量。
pivot(index, columns, values)	根据此DataFrame的3列生成“pivot”表。
pivot_table(data[, values, index, columns, …])	创建一个电子表格样式的数据透视表作为DataFrame。
crosstab(index, columns[, values, rownames, …])	计算两个（或更多）因子的简单交叉列表。
cut(x, bins[, right, labels, retbins, …])	Bin值为离散间隔。
qcut(x, q[, labels, retbins, precision, …])	基于分位数的离散化功能。
merge(left, right[, how, on, left_on, …])	通过按列或索引执行数据库样式的连接操作来合并DataFrame对象。
merge_ordered(left, right[, on, left_on, …])	使用为时序数据等有序数据设计的可选填充/插值执行合并。
merge_asof(left, right[, on, left_on, …])	执行asof合并。
concat(objs[, axis, join, join_axes, …])	沿特定轴连接pandas对象，沿其他轴使用可选的设置逻辑。
get_dummies(data[, prefix, prefix_sep, …])	将分类变量转换为虚拟/指示变量
factorize(values[, sort, order, …])	将对象编码为枚举类型或分类变量。
unique(values)	哈希表基于唯一。
wide_to_long(df, stubnames, i, j[, sep, suffix])	宽面板到长格式。

Top-level missing data

isna(obj)	检测类似数组的对象的缺失值。
isnull(obj)	检测类似数组的对象的缺失值。
notna(obj)	检测类似数组的对象的非缺失值。
notnull(obj)	检测类似数组的对象的非缺失值。

Top-level conversions

to_numeric(arg[, errors, downcast])	将参数转换为数字类型。

Top-level dealing with datetimelike

to_datetime(arg[, errors, dayfirst, …])	将参数转换为datetime。
to_timedelta(arg[, unit, box, errors])	将参数转换为timedelta
date_range([start, end, periods, freq, tz, …])	返回固定频率DatetimeIndex。
bdate_range([start, end, periods, freq, tz, …])	返回固定频率DatetimeIndex，以工作日作为默认频率
period_range([start, end, periods, freq, name])	返回固定频率PeriodIndex，以日（日历）作为默认频率
timedelta_range([start, end, periods, freq, …])	返回固定频率TimedeltaIndex，以day作为默认频率
infer_freq(index[, warn])	根据输入索引推断最可能的频率。

Top-level dealing with intervals

interval_range([start, end, periods, freq, …])	返回固定频率IntervalIndex

Top-level evaluation

eval(expr[, parser, engine, truediv, …])	使用各种后端将Python表达式评估为字符串。

Testing

test([extra_args])	

Series

Constructor

Series([data, index, dtype, name, copy, …])	带轴标签的一维ndarray（包括时间序列）。

Attributes

Axes

Series.index	系列的索引（轴标签）。
Series.values	返回系列为ndarray或ndarray-like取决于dtype
Series.dtype	返回基础数据的dtype对象
Series.ftype	如果数据稀疏则返回
Series.shape	返回基础数据形状的元组
Series.nbytes	返回基础数据中的字节数
Series.ndim	根据定义1，返回基础数据的维数
Series.size	返回基础数据中的元素数量
Series.strides	返回基础数据的步幅
Series.itemsize	返回基础数据项的dtype的大小
Series.base	如果共享基础数据的内存，则返回基础对象
Series.T	返回转置，根据定义自我
Series.memory_usage([index, deep])	返回Series的内存使用情况。
Series.hasnans	如果我有任何nans，我会回来; 实现各种性能加速
Series.flags	
Series.empty	
Series.dtypes	返回基础数据的dtype对象
Series.ftypes	如果数据稀疏则返回
Series.data	返回基础数据的数据指针
Series.is_copy	
Series.name	
Series.put(*args, **kwargs)	将put方法应用于其values属性（如果有）。

Conversion

Series.astype(dtype[, copy, errors])	将pandas对象转换为指定的dtype dtype。
Series.infer_objects()	尝试推断对象列的更好的dtypes。
Series.convert_objects([convert_dates, …])	（DEPRECATED）尝试推断对象列的更好dtype。
Series.copy([deep])	复制此对象的索引和数据。
Series.bool()	返回单个元素Pandas Object的书。
Series.to_period([freq, copy])	将Series从DatetimeIndex转换为具有所需频率的PeriodIndex（如果未传递，则从索引推断）
Series.to_timestamp([freq, how, copy])	在期间开始时转换为时间戳的datetimedex
Series.tolist()	返回值列表。
Series.get_values()	与值相同（但处理稀疏转换）; 是一种观点

Indexing, iteration

Series.get(key[, default])	从给定键的对象获取项目（DataFrame列，Panel切片等）。
Series.at	访问行/列标签对的单个值。
Series.iat	按整数位置访问行/列对的单个值。
Series.loc	通过标签或布尔数组访问一组行和列。
Series.iloc	纯粹基于整数位置的索引，用于按位置选择。
Series.__iter__()	返回值的迭代器。
Series.iteritems()	懒惰地迭代（索引，值）元组
Series.items()	懒惰地迭代（索引，值）元组
Series.keys()	索引的别名
Series.pop(item)	返回项目并从框架中删除。
Series.item()	将基础数据的第一个元素作为python标量返回
Series.xs(key[, axis, level, drop_level])	返回Series / DataFrame的横截面（行或列）。

Binary operator functions

Series.add(other[, level, fill_value, axis])	添加系列和其他元素（二元运算符添加）。
Series.sub(other[, level, fill_value, axis])	减去序列和其他元素（二元运算符子）。
Series.mul(other[, level, fill_value, axis])	系列和其他的乘法，元素（二元运算符mul）。
Series.div(other[, level, fill_value, axis])	系列和其他的浮动划分，元素方式（二元算子truediv）。
Series.truediv(other[, level, fill_value, axis])	系列和其他的浮动划分，元素方式（二元算子truediv）。
Series.floordiv(other[, level, fill_value, axis])	系列和其他的整数除法，元素方式（二元运算符floordiv）。
Series.mod(other[, level, fill_value, axis])	系列和其他的模数，元素方式（二元运算符mod）。
Series.pow(other[, level, fill_value, axis])	系列和其他元素的指数幂（二元运算符pow）。
Series.radd(other[, level, fill_value, axis])	添加系列和其他元素（二元运算符radd）。
Series.rsub(other[, level, fill_value, axis])	减去序列和其他元素（二元运算符rsub）。
Series.rmul(other[, level, fill_value, axis])	系列和其他的乘法，元素（二元运算符rmul）。
Series.rdiv(other[, level, fill_value, axis])	系列和其他的浮动划分，元素方式（二元算子rtruediv）。
Series.rtruediv(other[, level, fill_value, axis])	系列和其他的浮动划分，元素方式（二元算子rtruediv）。
Series.rfloordiv(other[, level, fill_value, …])	系列和其他的整数除法，元素方式（二元运算符rfloordiv）。
Series.rmod(other[, level, fill_value, axis])	系列和其他的模数，元素方式（二元运算符rmod）。
Series.rpow(other[, level, fill_value, axis])	系列和其他元素的指数幂（二元运算符rpow）。
Series.combine(other, func[, fill_value])	当一个系列或另一个系列中缺少索引时，使用给定函数对两个系列执行元素二进制运算，并带有可选填充值
Series.combine_first(other)	组合系列值，首先选择调用Series的值。
Series.round([decimals])	将系列中的每个值舍入到给定的小数位数。
Series.lt(other[, level, fill_value, axis])	少于系列和其他元素（二元运算符lt）。
Series.gt(other[, level, fill_value, axis])	大于系列和其他元素（二元运算符gt）。
Series.le(other[, level, fill_value, axis])	小于或等于系列和其他元素（二元运算符文件）。
Series.ge(other[, level, fill_value, axis])	大于或等于系列和其他元素（二元运算符ge）。
Series.ne(other[, level, fill_value, axis])	不等于系列和其他元素（二元运算符ne）。
Series.eq(other[, level, fill_value, axis])	等于系列和其他元素（二元运算符eq）。
Series.product([axis, skipna, level, …])	返回请求轴的值的乘积
Series.dot(other)	矩阵乘法与DataFrame或内部产品与Series对象。

Function application, GroupBy & Window

Series.apply(func[, convert_dtype, args])	调用Series的值的函数。
Series.agg(func[, axis])	使用指定轴上的一个或多个操作进行聚合。
Series.aggregate(func[, axis])	使用指定轴上的一个或多个操作进行聚合。
Series.transform(func, *args, **kwargs)	调用函数生成类似索引的NDFrame并返回带有转换值的NDFrame
Series.map(arg[, na_action])	使用输入对应（字典，系列或函数）映射Series的值。
Series.groupby([by, axis, level, as_index, …])	使用mapper（dict或key函数，将给定函数应用于组，将结果作为系列返回）或通过一系列列的组系列。
Series.rolling（window [，min_periods，...]）提供滚动窗口计算。
Series.expanding([min_periods, center, axis])	提供扩展转换。
Series.ewm([com, span, halflife, alpha, …])	提供指数加权函数
Series.pipe(func, *args, **kwargs)	应用func（self，* args，** kwargs）

Computations / Descriptive Stats

Series.abs()	返回具有每个元素的绝对数值的Series / DataFrame。
Series.all([axis, bool_only, skipna, level])	返回是否所有元素都是True，可能是在轴上。
Series.any([axis, bool_only, skipna, level])	返回任何元素在请求的轴上是否为True。
Series.autocorr([lag])	Lag-N自相关
Series.between(left, right[, inclusive])	返回boolean Series等效于left <= series <= right。
Series.clip([lower, upper, axis, inplace])	在输入阈值处修剪值。
Series.clip_lower(threshold[, axis, inplace])	返回值低于阈值截断的输入的副本。
Series.clip_upper(threshold[, axis, inplace])	输入的返回副本，其值超过给定值（截断）。
Series.corr(other[, method, min_periods])	计算与其他系列的相关性，不包括缺失值
Series.count([level])	返回系列中非NA / null观测值的返回数
Series.cov(other[, min_periods])	计算与Series的协方差，不包括缺失值
Series.cummax([axis, skipna])	返回DataFrame或Series轴上的累积最大值。
Series.cummin([axis, skipna])	返回DataFrame或Series轴上的累积最小值。
Series.cumprod([axis, skipna])	通过DataFrame或Series轴返回累积产品。
Series.cumsum([axis, skipna])	返回DataFrame或Series轴上的累积和。
Series.describe([percentiles, include, exclude])	生成描述性统计数据，总结数据集分布的集中趋势，分散和形状，不包括NaN值。
Series.diff([periods])	第一个离散的元素差异。
Series.factorize([sort, na_sentinel])	将对象编码为枚举类型或分类变量。
Series.kurt([axis, skipna, level, numeric_only])	使用Fisher对峰度的定义（正常峰度== 0.0），在请求轴上返回无偏峰度。
Series.mad([axis, skipna, level])	返回请求轴的值的平均绝对偏差
Series.max([axis, skipna, level, numeric_only])	此方法返回对象中的最大值。
Series.mean([axis, skipna, level, numeric_only])	返回请求轴的值的平均值
Series.median([axis, skipna, level, …])	返回请求轴的值的中值
Series.min([axis, skipna, level, numeric_only])	此方法返回对象中的最小值。
Series.mode()	返回数据集的模式。
Series.nlargest([n, keep])	返回最大的n个元素。
Series.nsmallest([n, keep])	返回最小的n个元素。
Series.pct_change([periods, fill_method, …])	当前元素和先前元素之间的百分比变化。
Series.prod([axis, skipna, level, …])	返回请求轴的值的乘积
Series.quantile([q, interpolation])	给定分位数处的返回值，即la numpy.percentile。
Series.rank([axis, method, numeric_only, …])	沿轴计算数值数据等级（1到n）。
Series.sem([axis, skipna, level, ddof, …])	在请求的轴上返回均值的无偏标准误差。
Series.skew([axis, skipna, level, numeric_only])	返回请求轴的无偏偏差，由N-1归一化
Series.std([axis, skipna, level, ddof, …])	返回请求轴上的样本标准偏差。
Series.sum([axis, skipna, level, …])	返回请求轴的值的总和
Series.var([axis, skipna, level, ddof, …])	在请求的轴上返回无偏差异。
Series.kurtosis([axis, skipna, level, …])	使用Fisher对峰度的定义（正常峰度== 0.0），在请求轴上返回无偏峰度。
Series.unique()	返回Series对象的唯一值。
Series.nunique([dropna])	返回对象中唯一元素的数量。
Series.is_unique	如果对象中的值是唯一的，则返回布尔值
Series.is_monotonic	如果对象中的值是monotonic_increasing，则返回布尔值
Series.is_monotonic_increasing	如果对象中的值是monotonic_increasing，则返回布尔值
Series.is_monotonic_decreasing	如果对象中的值是monotonic_decreasing，则返回布尔值
Series.value_counts([normalize, sort, …])	返回包含唯一值计数的对象。
Series.compound([axis, skipna, level])	返回请求轴的值的复合百分比
Series.nonzero()	返回非零元素的整数索引
Series.ptp([axis, skipna, level, numeric_only])	返回最大值和之间的差值

Reindexing / Selection / Label manipulation

Series.align(other[, join, axis, level, …])	使用指定的每个轴索引的连接方法将轴上的两个对象对齐
Series.drop([labels, axis, index, columns, …])	返回已删除指定索引标签的系列。
Series.drop_duplicates([keep, inplace])	返回系列，删除重复值。
Series.duplicated([keep])	指示重复的系列值。
Series.equals(other)	确定两个NDFrame对象是否包含相同的元素。
Series.first(offset)	用于基于日期偏移量化时间序列数据的初始时段的便捷方法。
Series.head([n])	返回前n行。
Series.idxmax([axis, skipna])	返回最大值的行标签。
Series.idxmin([axis, skipna])	返回最小值的行标签。
Series.isin(values)	检查系列中是否包含值。
Series.last(offset)	用于基于日期偏移量化时间序列数据的最终时段的便捷方法。
Series.reindex([index])	使用可选填充逻辑将系列符合到新索引，将NA / NaN放置在先前索引中没有值的位置。
Series.reindex_like(other[, method, copy, …])	将具有匹配索引的对象返回给我自己。
Series.rename([index])	更改系列索引标签或名称
Series.rename_axis(mapper[, axis, copy, inplace])	更改索引或列的名称。
Series.reset_index([level, drop, name, inplace])	使用索引重置生成新的DataFrame或Series。
Series.sample([n, frac, replace, weights, …])	从对象轴返回随机的项目样本。
Series.select(crit[, axis])	（DEPRECATED）返回与轴标签匹配条件对应的数据
Series.set_axis(labels[, axis, inplace])	将所需索引分配给给定轴。
Series.take(indices[, axis, convert, is_copy])	沿轴返回给定位置索引中的元素。
Series.tail([n])	返回最后n行。
Series.truncate([before, after, axis, copy])	在某个索引值之前和之后截断Series或DataFrame。
Series.where(cond[, other, inplace, axis, …])	返回与self相同形状的对象，其对应的条目来自self，其中cond为True，否则来自其他。
Series.mask(cond[, other, inplace, axis, …])	返回与self相同形状的对象，其对应的条目来自self，其中cond为False，否则来自other。
Series.add_prefix(prefix)	带有字符串前缀的前缀标签。
Series.add_suffix(suffix)	带有字符串后缀的后缀标签。
Series.filter([items, like, regex, axis])	根据指定索引中的标签设置数据框的行或列。

Missing data handling

Series.isna()	检测缺失值。
Series.notna()	检测现有（非缺失）值。
Series.dropna([axis, inplace])	返回删除了缺失值的新系列。
Series.fillna([value, method, axis, …])	使用指定的方法填充NA / NaN值
Series.interpolate([method, axis, limit, …])	根据不同的方法插值。

Reshaping, sorting

Series.argsort([axis, kind, order])	覆盖ndarray.argsort。
Series.argmin([axis, skipna])	（已弃用）..已弃用:: 0.21.0拆散，a.k.a。
Series.reorder_levels(order)	使用输入顺序重新排列索引级别。
Series.sort_values([axis, ascending, …])	按值排序。
Series.sort_index([axis, level, ascending, …])	按索引标签排序系列。
Series.swaplevel([i, j, copy])	在MultiIndex中交换i和j级别
Series.unstack([level, fill_value])	拆散，a.k.a。
Series.searchsorted(value[, side, sorter])	查找应插入元素以维护顺序的索引。
Series.ravel([order])	将展平的底层数据作为ndarray返回
Series.repeat(repeats, *args, **kwargs)	重复系列的元素。
Series.squeeze([axis])	挤压长度1维。
Series.view([dtype])	创建系列的新视图。
Series.sortlevel([level, ascending, …])	（已弃用）按所选级别对MultiIndex排序系列。

Combining / joining / merging

Series.append(to_append[, ignore_index, …])	连接两个或更多系列。
Series.replace([to_replace, value, inplace, …])	用值替换to_replace中给出的值。
Series.update(other)	使用传递的Series中的非NA值修改系列。

Time series-related

Series.asfreq(freq[, method, how, …])	将TimeSeries转换为指定的频率。
Series.asof(where[, subset])	获取没有任何NaN的最后一行（或者在没有NaN的情况下考虑仅使用DataFrame情况下的列子集的最后一行）
Series.shift([periods, freq, axis])	使用可选的时间频率按期望的周期数移动索引
Series.first_valid_index()	返回第一个非NA / null值的索引。
Series.last_valid_index()	返回最后一个非NA / null值的索引。
Series.resample(rule[, how, axis, …])	频率转换和时间序列重采样的便捷方法。
Series.tz_convert(tz[, axis, level, copy])	将tz感知轴转换为目标时区。
Series.tz_localize(tz[, axis, level, copy, …])	将tz-naive TimeSeries本地化为目标时区。
Series.at_time(time[, asof])	在特定时间选择值（例如
Series.between_time(start_time, end_time[, …])	选择一天中特定时间之间的值（例如，上午9：00-9：30）。
Series.tshift([periods, freq, axis])	如果可用，使用索引的频率来移动时间索引。
Series.slice_shift([periods, axis])	相当于移位而不复制数据。

Datetimelike Properties
Series.dt可用于以datetimelike的形式访问系列的值，并返回多个属性。 这些可以像Series.dt。一样访问。

Datetime Properties

Series.dt.date	返回numpy数组的python datetime.date对象（即没有时区信息的Timestamps的日期部分）。
Series.dt.time	返回datetime.time的numpy数组。
Series.dt.year	日期时间
Series.dt.month	月份为1月= 1，12月= 12
Series.dt.day	日期时间的日子
Series.dt.hour	日期时间
Series.dt.minute	日期时间的分钟
Series.dt.second	日期时间的秒数
Series.dt.microsecond	日期时间的微秒
Series.dt.nanosecond	日期时间的纳秒
Series.dt.week	一年中的一周序数
Series.dt.weekofyear	一年中的一周序数
Series.dt.dayofweek	星期一= 0，星期日= 6的星期几
Series.dt.weekday	星期一= 0，星期日= 6的星期几
Series.dt.dayofyear	一年中的序数日
Series.dt.quarter	日期的四分之一
Series.dt.is_month_start	逻辑指示是否每月的第一天（由频率定义）
Series.dt.is_month_end	指示日期是否是该月的最后一天。
Series.dt.is_quarter_start	指示日期是否是一个季度的第一天。
Series.dt.is_quarter_end	指示日期是否是一个季度的最后一天。
Series.dt.is_year_start	指明日期是否是一年的第一天。
Series.dt.is_year_end	指明日期是一年中的最后一天。
Series.dt.is_leap_year	布尔指示符，如果日期属于闰年。
Series.dt.daysinmonth	本月的天数
Series.dt.days_in_month	本月的天数
Series.dt.tz	
Series.dt.freq	

Datetime Methods

Series.dt.to_period(*args, **kwargs)	以特定频率转换为PeriodIndex。
Series.dt.to_pydatetime()	将数据作为本机Python日期时间对象的数组返回
Series.dt.tz_localize(*args, **kwargs)	将tz-naive DatetimeIndex本地化为tz-aware DatetimeIndex。
Series.dt.tz_convert(*args, **kwargs)	将tz-aware DatetimeIndex从一个时区转换为另一个时区。
Series.dt.normalize(*args, **kwargs)	将时间转换为午夜。
Series.dt.strftime(*args, **kwargs)	使用指定的date_format转换为Index。
Series.dt.round(*args, **kwargs)	将数据舍入到指定的频率。
Series.dt.floor(*args, **kwargs)	将数据置于指定的频率。
Series.dt.ceil(*args, **kwargs)	将数据ceil到指定的频率。
Series.dt.month_name(*args, **kwargs)	返回具有指定语言环境的DateTimeIndex的月份名称。
Series.dt.day_name(*args, **kwargs)	返回具有指定语言环境的DateTimeIndex的日期名称。

Timedelta Properties

Series.dt.days	每个元素的天数。
Series.dt.seconds	每个元素的秒数（> = 0且小于1天）。
Series.dt.microseconds	每个元素的微秒数（> = 0且小于1秒）。
Series.dt.nanoseconds	每个元素的纳秒数（> = 0且小于1微秒）。
Series.dt.components	返回Timedeltas的组件（天，小时，分钟，秒，毫秒，微秒，纳秒）的数据帧。

Timedelta Methods

Series.dt.to_pytimedelta()	返回本机datetime.timedelta对象的数组。
Series.dt.total_seconds(*args, **kwargs)	返回每个元素的总持续时间，以秒为单位表示

String handling¶

Series.str可用于以字符串形式访问系列的值，并对其应用多种方法。 这些可以像Series.str。一样访问。

Series.str.capitalize()	将Series / Index中的字符串转换为大写。
Series.str.cat([others, sep, na_rep, join])	使用给定的分隔符连接Series / Index中的字符串。
Series.str.center(width[, fillchar])	使用附加字符填充系列/索引中字符串的左侧和右侧。
Series.str.contains(pat[, case, flags, na, …])	测试模式或正则表达式是否包含在系列或索引的字符串中。
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])	对于系列中的每个主题字符串，从正则表达式pat的第一个匹配中提取组。
Series.str.extractall(pat[, flags])	对于系列中的每个主题字符串，从正则表达式pat的所有匹配中提取组。
Series.str.find(sub[, start, end])	返回Series / Index中每个字符串中的最低索引，其中子字符串完全包含在[start：end]之间。
Series.str.findall(pat[, flags])	在系列/索引中查找所有出现的模式或正则表达式。
Series.str.get(i)	从指定位置的每个组件中提取元素。
Series.str.index(sub[, start, end])	返回每个字符串中的最低索引，其中子字符串完全包含在[start：end]之间。
Series.str.join(sep)	使用传递的分隔符连接包含在Series / Index中的元素的列表。
Series.str.len()	计算系列/索引中每个字符串的长度。
Series.str.ljust(width[, fillchar])	使用附加字符填充系列/索引中字符串的右侧。
Series.str.lower()	将Series / Index中的字符串转换为小写.
Series.str.lstrip([to_strip])	从左侧的系列/索引中的每个字符串中删除空格（包括换行符）。
Series.str.match(pat[, case, flags, na, …])	确定每个字符串是否与正则表达式匹配。
Series.str.normalize(form)	返回Series / Index中字符串的Unicode普通表单。
Series.str.pad(width[, side, fillchar])	在系列/索引中填充字符串，并在指定的一侧添加一个字符。
Series.str.partition([pat, expand])	在第一次出现sep时拆分字符串，并返回包含分隔符之前的部分的3个元素，分隔符本身以及分隔符之后的部分。
Series.str.repeat(repeats)	按指定的次数复制系列/索引中的每个字符串。
Series.str.replace(pat, repl[, n, case, …])	用一些其他字符串替换Series / Index中出现的pattern / regex。
Series.str.rfind(sub[, start, end])	返回Series / Index中每个字符串中的最高索引，其中子字符串完全包含在[start：end]之间。
Series.str.rindex(sub[, start, end])	返回每个字符串中的最高索引，其中子字符串完全包含在[start：end]之间。
Series.str.rjust(width[, fillchar])	使用附加字符填充系列/索引中字符串的左侧。
Series.str.rpartition([pat, expand])	在最后一次出现sep时拆分字符串，并返回包含分隔使用0填充Series / Index中字符串的左侧。符之前的部分的3个元素，分隔符本身以及分隔符之后的部分。
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 / Index中的每个字符串，从字符串的末尾开始并向前工作。
Series.str.startswith(pat[, na])	测试每个字符串元素的开头是否与模式匹配。
Series.str.strip([to_strip])	从左侧和右侧剥离系列/索引中每个字符串的空白（包括换行符）。
Series.str.swapcase()	将Series / Index中的字符串转换为swapcased。
Series.str.title()	将系列/索引中的字符串转换为标题。
Series.str.translate(table[, deletechars])	通过给定的映射表映射字符串中的所有字符。
Series.str.upper()	将Series / Index中的字符串转换为大写。
Series.str.wrap(width, **kwargs)	将Series / Index中的长字符串换行，以长度小于给定宽度的段落格式化。
Series.str.zfill(width)	使用0填充Series / Index中字符串的左侧。
Series.str.isalnum()	检查Series / Index中每个字符串中的所有字符是否为字母数字.
Series.str.isalpha()	检查Series / Index中每个字符串中的所有字符是否都是字母.
Series.str.isdigit()	检查Series / Index中每个字符串中的所有字符是否为数字.
Series.str.isspace()	检查Series / Index中每个字符串中的所有字符是否都是空格.
Series.str.islower()	检查Series / Index中每个字符串中的所有字符是否都是小写.
Series.str.isupper()	检查Series / Index中每个字符串中的所有字符是否都是大写.
Series.str.istitle()	检查Series / Index中每个字符串中的所有字符是否都是标题.
Series.str.isnumeric()	检查Series / Index中每个字符串中的所有字符是否都是数字.
Series.str.isdecimal()	检查Series / Index中每个字符串中的所有字符是否为十进制.
Series.str.get_dummies([sep])	用sep拆分Series中的每个字符串，并返回一个虚拟/指示变量框。

Categorical

Pandas定义了一种自定义数据类型，用于表示只能使用有限的固定值集的数据。 分类的dtype可以用pandas.api.types.CategoricalDtype来描述。

api.types.CategoricalDtype([categories, ordered])	键入具有类别和有序性的分类数据
api.types.CategoricalDtype.categories	包含允许的唯一类别的索引。
api.types.CategoricalDtype.ordered	类别是否具有有序关系

分类数据可以存储在pandas.Categorical中
Categorical(values[, categories, ordered, …])	表示经典R / S-plus方式的分类变量

已有类别和整数代码时，可以使用替代的Categorical.from_codes（）构造函数：
Categorical.from_codes（codes，categories [，...]）从代码和类别数组中创建一个分类类型。

dtype信息可在分类中找到
Categorical.dtype	此实例的CategoricalDtype
Categorical.categories	这种分类的类别。
Categorical.ordered	类别是否具有有序关系
Categorical.codes	此类别的类别代码。

np.asarray（分类）通过实现数组接口来工作。 请注意，这会将Categorical转换回NumPy数组，因此不会保留类别和订单信息！

Categorical.__array__([dtype])	numpy数组接口。

分类可以存储在Series或DataFrame中。 要创建一系列dtype类别，请使用cat = s.astype（dtype）或Series（...，dtype = dtype），其中dtype是

字符串'category'
CategoricalDtype的一个实例。
如果Series是dtype CategoricalDtype，则Series.cat可用于更改分类数据。 此访问器类似于Series.dt或Series.str，具有以下可用方法和属性：

eries.cat.categories	这种分类的类别。
Series.cat.ordered	类别是否具有有序关系
Series.cat.codes	
Series.cat.rename_categories(*args, **kwargs)	重命名类别。
Series.cat.reorder_categories(*args, **kwargs)	重新排序new_categories中指定的类别。
Series.cat.add_categories(*args, **kwargs)	添加新类别。
Series.cat.remove_categories(*args, **kwargs)	删除指定的类别。
Series.cat.remove_unused_categories(*args, …)	删除未使用的类别。
Series.cat.set_categories(*args, **kwargs)	将类别设置为指定的new_categories。
Series.cat.as_ordered(*args, **kwargs)	设置要排序的分类
Series.cat.as_unordered(*args, **kwargs)	将Categorical设置为无序

Plotting

Series.plot既是可调用方法，也是Serial.plot。形式的特定绘图方法的命名空间属性。

Series.plot([kind, ax, figsize, ….])	系列绘图访问器和方法
Series.plot.area(**kwds)	区域情节
Series.plot.bar(**kwds)	垂直条形图
Series.plot.barh(**kwds)	单杠图
Series.plot.box(**kwds)	箱形图
Series.plot.density([bw_method, ind])	使用高斯核生成核密度估计图。
Series.plot.hist([bins])	直方图
Series.plot.kde([bw_method, ind])	使用高斯核生成核密度估计图。
Series.plot.line(**kwds)	线图
Series.plot.pie(**kwds)	饼形图
Series.hist([by, ax, grid, xlabelsize, …])	使用matplotlib绘制输入序列的直方图

Serialization / IO / Conversion

Series.to_pickle(path[, compression, protocol])	Pickle（序列化）对象到文件。
Series.to_csv([path, index, sep, na_rep, …])	将Series写入逗号分隔值（csv）文件
Series.to_dict([into])	将Series转换为{label - > value} dict或dict-like对象。
Series.to_excel(excel_writer[, sheet_name, …])	将系列写入Excel工作表
Series.to_frame([name])	将Series转换为DataFrame
Series.to_xarray()	从pandas对象返回一个xarray对象。
Series.to_hdf(path_or_buf, key, **kwargs)	使用HDFStore将包含的数据写入HDF5文件。
Series.to_sql(name, con[, schema, …])	将存储在DataFrame中的记录写入SQL数据库。
Series.to_msgpack([path_or_buf, encoding])	msgpack（序列化）对象输入文件路径
Series.to_json([path_or_buf, orient, …])	将对象转换为JSON字符串。
Series.to_sparse([kind, fill_value])	将Series转换为SparseSeries
Series.to_dense()	返回NDFrame的密集表示（与稀疏相反）
Series.to_string([buf, na_rep, …])	渲染系列的字符串表示形式
Series.to_clipboard([excel, sep])	将对象复制到系统剪贴板。
Series.to_latex([buf, columns, col_space, …])	将对象渲染到表格环境表。

Sparse

SparseSeries.to_coo([row_levels, …])	使用MultiIndex从SparseSeries创建scipy.sparse.coo_matrix。
SparseSeries.from_coo(A[, dense_index])	从scipy.sparse.coo_matrix创建SparseSeries。

DataFrame¶

Constructor

DataFrame([data, index, columns, dtype, copy])	Two-dimensional size-mutable, potentially heterogeneous tabular data structure with labeled axes (rows and columns).

Attributes and underlying data

Axes

DataFrame.index	DataFrame的索引（行标签）。
DataFrame.columns	DataFrame的列标签。
DataFrame.dtypes	返回DataFrame中的dtypes。
DataFrame.ftypes	返回DataFrame中的ftypes（稀疏/密集和dtype的指示）。
DataFrame.get_dtype_counts()	返回此对象中唯一dtypes的计数。
DataFrame.get_ftype_counts()	（DEPRECATED）返回此对象中唯一ftypes的计数。
DataFrame.select_dtypes([include, exclude])	根据列dtypes返回DataFrame列的子集。
DataFrame.values	返回DataFrame的Numpy表示。
DataFrame.get_values()	将稀疏值转换为密集后返回一个ndarray。
DataFrame.axes	返回表示DataFrame轴的列表。
DataFrame.ndim	返回表示轴/数组维数的int。
DataFrame.size	返回一个int，表示此对象中的元素数。
DataFrame.shape	返回表示DataFrame维度的元组。
DataFrame.memory_usage([index, deep])	以字节为单位返回每列的内存使用情况。
DataFrame.empty	指示DataFrame是否为空。
DataFrame.is_copy	

Conversion

DataFrame.astype(dtype[, copy, errors])	将pandas对象转换为指定的dtype dtype。
DataFrame.convert_objects([convert_dates, …])	（DEPRECATED）尝试推断对象列的更好dtype。
DataFrame.infer_objects()	尝试推断对象列的更好的dtypes。
DataFrame.copy([deep])	复制此对象的索引和数据。
DataFrame.isna()	检测缺失值。
DataFrame.notna()	检测现有（非缺失）值。
DataFrame.bool()	返回单个元素Pandas Object的书。

Indexing, iteration

DataFrame.head([n])	返回前n行。
DataFrame.at	访问行/列标签对的单个值。
DataFrame.iat	按整数位置访问行/列对的单个值。
DataFrame.loc	通过标签或布尔数组访问一组行和列。
DataFrame.iloc	纯粹基于整数位置的索引，用于按位置选择。
DataFrame.insert(loc, column, value[, …])	将列插入指定位置的DataFrame。
DataFrame.insert(loc, column, value[, …])	将列插入指定位置的DataFrame。
DataFrame.__iter__()	迭代infor轴
DataFrame.items()	迭代器（列名，系列）对。
DataFrame.keys()	获取“信息轴”（请参阅索引了解更多信息）
DataFrame.iteritems()	迭代器（列名，系列）对。
DataFrame.iterrows()	将DataFrame行迭代为（index，Series）对。
DataFrame.itertuples([index, name])	将DataFrame行作为namedtuples迭代，索引值作为元组的第一个元素。
DataFrame.lookup(row_labels, col_labels)	DataFrame的基于标签的“花式索引”功能。
DataFrame.pop(item)	返回项目并从框架中删除。
DataFrame.tail([n])	返回最后n行。
DataFrame.xs(key[, axis, level, drop_level])	返回Series / DataFrame的横截面（行或列）。
DataFrame.get(key[, default])	从给定键的对象获取项目（DataFrame列，Panel切片等）。
DataFrame.isin(values)	返回boolean DataFrame，显示DataFrame中的每个元素是否包含在值中。
DataFrame.where(cond[, other, inplace, …])	返回与self相同形状的对象，其对应的条目来自self，其中cond为True，否则来自其他
DataFrame.mask(cond[, other, inplace, axis, …])	返回与self相同形状的对象，其对应的条目来自self，其中cond为False，否则来自other。
DataFrame.query(expr[, inplace])	使用布尔表达式查询帧的列。

Binary operator functions

DataFrame.add(other[, axis, level, fill_value])	添加数据帧和其他元素（二元运算符添加）。
DataFrame.sub(other[, axis, level, fill_value])	减去数据帧和其他元素（二元运算符子）。
DataFrame.mul(other[, axis, level, fill_value])	数据帧和其他元素的乘法（二元运算符mul）。
DataFrame.div(other[, axis, level, fill_value])	浮动划分数据帧和其他元素（二元运算符truediv）。
DataFrame.truediv(other[, axis, level, …])	浮动划分数据帧和其他元素（二元运算符truediv）。
DataFrame.floordiv(other[, axis, level, …])	数据帧和其他元素的整数划分（二元运算符floordiv）。
DataFrame.mod(other[, axis, level, fill_value])	数据帧的模数和其他元素（二元运算符mod）。
DataFrame.pow(other[, axis, level, fill_value])	数据帧和其他元素的指数幂（二元运算符pow）。
DataFrame.dot(other)	矩阵乘法与DataFrame或Series对象。
DataFrame.radd(other[, axis, level, fill_value])	添加数据帧和其他元素（二元运算符radd）。
DataFrame.rsub(other[, axis, level, fill_value])	减去数据帧和其他元素（二元运算符rsub）。
DataFrame.rmul(other[, axis, level, fill_value])	数据帧和其他元素的乘法（二元运算符rmul）。
DataFrame.rdiv(other[, axis, level, fill_value])	数据帧和其他元素的浮动划分（二元运算符rtruediv）。
DataFrame.rtruediv(other[, axis, level, …])	数据帧和其他元素的浮动划分（二元运算符rtruediv）。
DataFrame.rfloordiv(other[, axis, level, …])	数据帧和其他元素的整数划分（二元运算符rfloordiv）。
DataFrame.rmod(other[, axis, level, fill_value])	数据帧的模数和其他元素（二元运算符rmod）。
DataFrame.rpow(other[, axis, level, fill_value])	数据帧和其他元素的指数幂（二元运算符rpow）。
DataFrame.lt(other[, axis, level])	用于灵活比较方法的包装器
DataFrame.gt(other[, axis, level])	用于灵活比较方法的包装器gt
DataFrame.le(other[, axis, level])	用于灵活比较方法的包装器
DataFrame.ge(other[, axis, level])	用于灵活比较方法的包装器 ge
DataFrame.ne(other[, axis, level])	用于灵活比较方法的包装器 ne
DataFrame.eq(other[, axis, level])	用于灵活比较方法的包装器 eq
DataFrame.combine(other, func[, fill_value, …])	添加两个DataFrame对象并且不传播NaN值，因此如果对于（列，时间）一个帧缺少值，它将默认为另一个帧的值（也可能是NaN）
DataFrame.combine_first(other)	将两个DataFrame对象组合在一起，默认为调用该方法的帧中的非空值。

Function application, GroupBy & Window

DataFrame.apply(func[, axis, broadcast, …])	沿DataFrame的轴应用函数。
DataFrame.applymap(func)	将函数元素应用于Dataframe。
DataFrame.pipe(func, *args, **kwargs)	应用func（self，* args，** kwargs）
DataFrame.agg(func[, axis])	使用指定轴上的一个或多个操作进行聚合。
DataFrame.aggregate(func[, axis])	使用指定轴上的一个或多个操作进行聚合。
DataFrame.transform(func, *args, **kwargs)	调用函数生成类似索引的NDFrame并返回带有转换值的NDFrame
DataFrame.groupby([by, axis, level, …])	使用mapper（dict或key函数，将给定函数应用于组，将结果作为系列返回）或通过一系列列的组系列。
DataFrame.rolling(window[, min_periods, …])	提供滚动窗口计算。
DataFrame.expanding([min_periods, center, axis])	提供扩展转换。
DataFrame.ewm([com, span, halflife, alpha, …])	提供指数加权函数

Computations / Descriptive Stats

DataFrame.abs()	返回具有每个元素的绝对数值的Series / DataFrame。
DataFrame.all([axis, bool_only, skipna, level])	返回是否所有元素都是True，可能是在轴上。
DataFrame.any([axis, bool_only, skipna, level])	返回任何元素在请求的轴上是否为True。
DataFrame.clip([lower, upper, axis, inplace])	在输入阈值处修剪值。
DataFrame.clip_lower(threshold[, axis, inplace])	返回值低于阈值截断的输入的副本。
DataFrame.clip_upper(threshold[, axis, inplace])	输入的返回副本，其值超过给定值（截断）。
DataFrame.compound([axis, skipna, level])	返回请求轴的值的复合百分比
DataFrame.corr([method, min_periods])	计算列的成对相关性，不包括NA / null值
DataFrame.corrwith(other[, axis, drop])	计算两个DataFrame对象的行或列之间的成对关联。
DataFrame.count([axis, level, numeric_only])	计算每列或每行的非NA单元格。
DataFrame.cov([min_periods])	计算列的成对协方差，不包括NA / null值。
DataFrame.cummax([axis, skipna])	返回DataFrame或Series轴上的累积最大值。
DataFrame.cummin([axis, skipna])	返回DataFrame或Series轴上的累积最小值。
DataFrame.cumprod([axis, skipna])	通过DataFrame或Series轴返回累积产品。
DataFrame.cumsum([axis, skipna])	返回DataFrame或Series轴上的累积和。
DataFrame.describe([percentiles, include, …])	生成描述性统计数据，总结数据集分布的集中趋势，分散和形状，不包括NaN值。
DataFrame.diff([periods, axis])	第一个离散的元素差异。
DataFrame.eval(expr[, inplace])	评估描述DataFrame列上的操作的字符串。
DataFrame.kurt([axis, skipna, level, …])	使用Fisher对峰度的定义（正常峰度== 0.0），在请求轴上返回无偏峰度。
DataFrame.kurtosis([axis, skipna, level, …])	使用Fisher对峰度的定义（正常峰度== 0.0），在请求轴上返回无偏峰度。
DataFrame.mad([axis, skipna, level])	返回请求轴的值的平均绝对偏差
DataFrame.max([axis, skipna, level, …])	此方法返回对象中的最大值。
DataFrame.mean([axis, skipna, level, …])	返回请求轴的值的平均值
DataFrame.median([axis, skipna, level, …])	返回请求轴的值的中值
DataFrame.min([axis, skipna, level, …])	此方法返回对象中的最小值。
DataFrame.mode([axis, numeric_only])	获取沿所选轴的每个元素的模式。
DataFrame.pct_change([periods, fill_method, …])	当前元素和先前元素之间的百分比变化。
DataFrame.prod([axis, skipna, level, …])	返回请求轴的值的乘积
DataFrame.product([axis, skipna, level, …])	返回请求轴的值的乘积
DataFrame.quantile([q, axis, numeric_only, …])	在请求的轴上返回给定分位数的值，即la numpy.percentile。
DataFrame.rank([axis, method, numeric_only, …])	沿轴计算数值数据等级（1到n）。
DataFrame.round([decimals])	将DataFrame舍入到可变数量的小数位。
DataFrame.sem([axis, skipna, level, ddof, …])	在请求的轴上返回均值的无偏标准误差。
DataFrame.skew([axis, skipna, level, …])	返回请求轴的无偏偏差，由N-1归一化
DataFrame.sum([axis, skipna, level, …])	返回请求轴的值的总和
DataFrame.std([axis, skipna, level, ddof, …])	返回请求轴上的样本标准偏差。
DataFrame.var([axis, skipna, level, ddof, …])	在请求的轴上返回无偏差异。
DataFrame.nunique([axis, dropna])	返回具有所请求轴上的不同观察数的系列。

Reindexing / Selection / Label manipulation

DataFrame.add_prefix(prefix)	带有字符串前缀的前缀标签。
DataFrame.add_suffix(suffix)	带有字符串后缀的后缀标签。
DataFrame.align(other[, join, axis, level, …])	使用指定的每个轴索引的连接方法将轴上的两个对象对齐
DataFrame.at_time(time[, asof])	在特定时间选择值（例如
DataFrame.between_time(start_time, end_time)	选择一天中特定时间之间的值（例如，上午9：00-9：30）。
DataFrame.drop([labels, axis, index, …])	从行或列中删除指定的标签。
DataFrame.drop_duplicates([subset, keep, …])	返回删除了重复行的DataFrame，可选择仅考虑某些列
DataFrame.duplicated([subset, keep])	返回boolean Series表示重复行，可选择仅考虑某些列
DataFrame.equals(other)	确定两个NDFrame对象是否包含相同的元素。
DataFrame.filter([items, like, regex, axis])	根据指定索引中的标签设置数据框的行或列。
DataFrame.first(offset)	用于基于日期偏移量化时间序列数据的初始时段的便捷方法。
DataFrame.head([n])	返回前n行。
DataFrame.idxmax([axis, skipna])	返回请求轴上第一次出现最大值的索引。
DataFrame.idxmin([axis, skipna])	返回首次出现最小请求轴的索引。
DataFrame.last(offset)	用于基于日期偏移量化时间序列数据的最终时段的便捷方法。
DataFrame.reindex([labels, index, columns, …])	使用可选填充逻辑将DataFrame符合到新索引，将NA / NaN放置在先前索引中没有值的位置。
DataFrame.reindex_axis(labels[, axis, …])	使用可选的填充逻辑将输入对象符合到新索引，将NA / NaN放置在先前索引中没有值的位置。
DataFrame.reindex_like(other[, method, …])	将具有匹配索引的对象返回给我自己。
DataFrame.rename([mapper, index, columns, …])	更改轴标签。
DataFrame.rename_axis(mapper[, axis, copy, …])	更改索引或列的名称。
DataFrame.reset_index([level, drop, …])	对于具有多级索引的DataFrame，在索引名称下的列中返回带有标签信息的新DataFrame，默认为“level_0”，“level_1”等。
DataFrame.sample([n, frac, replace, …])	从对象轴返回随机的项目样本。
DataFrame.select(crit[, axis])	（DEPRECATED）返回与轴标签匹配条件对应的数据
DataFrame.set_axis(labels[, axis, inplace])	将所需索引分配给给定轴。
DataFrame.set_index(keys[, drop, append, …])	使用一个或多个现有列设置DataFrame索引（行标签）。
DataFrame.tail([n])	返回最后n行。
DataFrame.take(indices[, axis, convert, is_copy])	沿轴返回给定位置索引中的元素。
DataFrame.truncate([before, after, axis, copy])	在某个索引值之前和之后截断Series或DataFrame。

Missing data handling

DataFrame.dropna([axis, how, thresh, …])	删除缺失的值。
DataFrame.fillna([value, method, axis, …])	使用指定的方法填充NA / NaN值
DataFrame.replace([to_replace, value, …])	用值替换to_replace中给出的值。
DataFrame.interpolate([method, axis, limit, …])	根据不同的方法插值。

Reshaping, sorting, transposing

DataFrame.pivot([index, columns, values])	返回由给定索引/列值组织的重新整形的DataFrame。
DataFrame.pivot_table([values, index, …])	创建一个电子表格样式的数据透视表作为DataFrame。
DataFrame.reorder_levels(order[, axis])	使用输入顺序重新排列索引级别。
DataFrame.sort_values(by[, axis, ascending, …])	按任一轴的值排序
DataFrame.sort_index([axis, level, …])	按标签排序对象（沿轴）
DataFrame.nlargest(n, columns[, keep])	按降序返回按列排序的前n行。
DataFrame.nsmallest(n, columns[, keep])	获取按n个最小列值排序的DataFrame行。
DataFrame.swaplevel([i, j, axis])	在特定轴上的MultiIndex中交换i和j级别
DataFrame.stack([level, dropna])	将指定级别从列堆叠到索引。
DataFrame.unstack([level, fill_value])	透视（必要的分层）索引标签的级别，返回具有新级别列标签的DataFrame，其最内层级别由透视索引标签组成。
DataFrame.swapaxes(axis1, axis2[, copy])	交换轴和交换值轴适当
DataFrame.melt([id_vars, value_vars, …])	“Unpivots”DataFrame从宽格式到长格式，可选择设置标识符变量。
DataFrame.squeeze([axis])	挤压长度1维。
DataFrame.to_panel()	（DEPRECATED）将长（堆叠）格式（DataFrame）转换为宽（3D，Panel）格式。
DataFrame.to_xarray()	从pandas对象返回一个xarray对象。
DataFrame.T	转置索引和列。
DataFrame.transpose(*args, **kwargs)	转置索引和列。

Combining / joining / merging

DataFrame.append(other[, ignore_index, …])	将其他行附加到此帧的末尾，返回一个新对象。
DataFrame.assign(**kwargs)	将新列分配给DataFrame，返回一个新对象（副本），并将新列添加到原始列中。
DataFrame.join(other[, on, how, lsuffix, …])	在索引或键列上与其他DataFrame连接列。
DataFrame.merge(right[, how, on, left_on, …])	通过按列或索引执行数据库样式的连接操作来合并DataFrame对象。
DataFrame.update(other[, join, overwrite, …])	使用另一个DataFrame中的非NA值进行就地修改。

Time series-related

DataFrame.asfreq(freq[, method, how, …])	将TimeSeries转换为指定的频率。
DataFrame.asof(where[, subset])	获取没有任何NaN的最后一行（或者在没有NaN的情况下考虑仅使用DataFrame情况下的列子集的最后一行）
DataFrame.shift([periods, freq, axis])	使用可选的时间频率按期望的周期数移动索引
DataFrame.slice_shift([periods, axis])	相当于移位而不复制数据。
DataFrame.tshift([periods, freq, axis])	如果可用，使用索引的频率来移动时间索引。
DataFrame.first_valid_index()	返回第一个非NA / null值的索引。
DataFrame.last_valid_index()	返回最后一个非NA / null值的索引。
DataFrame.resample(rule[, how, axis, …])	频率转换和时间序列重采样的便捷方法。
DataFrame.to_period([freq, axis, copy])	使用所需频率将DataFrame从DatetimeIndex转换为PeriodIndex（如果未传递，则从索引推断）
DataFrame.to_timestamp([freq, how, axis, copy])	在期间开始时转换为时间戳的DatetimeIndex
DataFrame.tz_convert(tz[, axis, level, copy])	将tz感知轴转换为目标时区。
DataFrame.tz_localize(tz[, axis, level, …])	将tz-naive TimeSeries本地化为目标时区。

Plotting

DataFrame.plot is both a callable method and a namespace attribute for specific plotting methods of the form DataFrame.plot..

DataFrame.plot([x, y, kind, ax, ….])	DataFrame绘制访问器和方法
DataFrame.plot.area([x, y])	区域情节
DataFrame.plot.bar([x, y])	垂直条形图。
DataFrame.plot.barh([x, y])	制作一个水平条形图。
DataFrame.plot.box([by])	制作DataFrame列的方框图。
DataFrame.plot.density([bw_method, ind])	使用高斯核生成核密度估计图。
DataFrame.plot.hexbin(x, y[, C, …])	生成六边形分箱图。
DataFrame.plot.hist([by, bins])	绘制DataFrame列的一个直方图。
DataFrame.plot.kde([bw_method, ind])	使用高斯核生成核密度估计图。
DataFrame.plot.line([x, y])	将DataFrame列绘制为线条。
DataFrame.plot.pie([y])	生成饼图。
DataFrame.plot.scatter(x, y[, s, c])	创建具有不同标记点大小和颜色的散点图。
DataFrame.boxplot([column, by, ax, …])	从DataFrame列创建一个箱形图。
DataFrame.hist([column, by, grid, …])	制作DataFrame的直方图。

Serialization / IO / Conversion

DataFrame.from_csv(path[, header, sep, …])	（已弃用）读取CSV文件。
DataFrame.from_dict(data[, orient, dtype, …])	从类似数组或dicts的dict构造DataFrame。
DataFrame.from_items(items[, columns, orient])	（DEPRECATED）从元组列表构造数据框
DataFrame.from_records(data[, index, …])	将结构化或记录ndarray转换为DataFrame
DataFrame.info([verbose, buf, max_cols, …])	打印DataFrame的简明摘要。
DataFrame.to_parquet(fname[, engine, …])	将DataFrame写入二进制镶木地板格式。
DataFrame.to_pickle(path[, compression, …])	Pickle（序列化）对象到文件。
DataFrame.to_csv([path_or_buf, sep, na_rep, …])	将DataFrame写入逗号分隔值（csv）文件
DataFrame.to_hdf(path_or_buf, key, **kwargs)	使用HDFStore将包含的数据写入HDF5文件。
DataFrame.to_sql(name, con[, schema, …])	将存储在DataFrame中的记录写入SQL数据库。
DataFrame.to_dict([orient, into])	将DataFrame转换为字典。
DataFrame.to_excel(excel_writer[, …])	将DataFrame写入Excel工作表
DataFrame.to_json([path_or_buf, orient, …])	将对象转换为JSON字符串。
DataFrame.to_html([buf, columns, col_space, …])	将DataFrame呈现为HTML表格。
DataFrame.to_feather(fname)	写出DataFrames的二进制羽毛格式
DataFrame.to_latex([buf, columns, …])	将对象渲染到表格环境表。
DataFrame.to_stata(fname[, convert_dates, …])	导出Stata二进制dta文件。
DataFrame.to_msgpack([path_or_buf, encoding])	msgpack（序列化）对象输入文件路径
DataFrame.to_gbq(destination_table, project_id)	将DataFrame写入Google BigQuery表。
DataFrame.to_records([index, convert_datetime64])	将DataFrame转换为NumPy记录数组。
DataFrame.to_sparse([fill_value, kind])	转换为SparseDataFrame
DataFrame.to_dense()	返回NDFrame的密集表示（与稀疏相反）
DataFrame.to_string([buf, columns, …])	将DataFrame渲染为控制台友好的表格输出。
DataFrame.to_clipboard([excel, sep])	将对象复制到系统剪贴板。
DataFrame.style	返回Styler对象的属性，该对象包含用于为DataFrame构建样式化HTML表示的方法。

Sparse

SparseDataFrame.to_coo()	将帧的内容作为稀疏的SciPy COO矩阵返回。

Panel

Constructor

Panel([data, items, major_axis, minor_axis, …])	（DEPRECATED）表示宽格式面板数据，存储为三维数组

Attributes and underlying data

Axes

items: axis 0; 每个项目对应一个包含在其中的DataFrame
major_axis: axis 1; 每个DataFrame的索引（行）
minor_axis: axis 2; 每个DataFrame的索引（行）
Panel.values	返回DataFrame的Numpy表示形式。
Panel.axes	返回内部NDFrame的索引标签
Panel.ndim	返回表示轴/数组维数的int。
Panel.size	返回一个int，表示此对象中的元素数。
Panel.shape	返回轴尺寸的元组
Panel.dtypes	返回DataFrame中的dtypes。
Panel.ftypes	返回DataFrame中的ftypes（稀疏/密集和dtype的指示）。
Panel.get_dtype_counts()	返回此对象中唯一dtypes的计数。
Panel.get_ftype_counts()	(DEPRECATED) DEPRECATED）返回此对象中唯一ftypes的计数。

Conversion

Panel.astype(dtype[, copy, errors])	将pandas对象转换为指定的dtype dtype。
Panel.copy([deep])	复制此对象的索引和数据。
Panel.isna()	检测缺失值。
Panel.notna()	检测现有（非缺失）值。

Getting and setting

Panel.get_value(*args, **kwargs)	（已弃用）在（项目，主要，次要）位置快速检索单个值
Panel.set_value(*args, **kwargs)	（已弃用）在（项目，主要，次要）位置快速设置单个值

Indexing, iteration, slicing

Panel.at	访问行/列标签对的单个值。
Panel.iat	按整数位置访问行/列对的单个值。
Panel.loc	通过标签或布尔数组访问一组行和列。
Panel.iloc	纯粹基于整数位置的索引，用于按位置选择。
Panel.__iter__()	迭代infor轴
Panel.iteritems()	在信息轴上迭代（标签，值）
Panel.pop(item)	返回项目并从框架中删除。
Panel.xs(key[, axis])	沿选定轴返回面板切片
Panel.major_xs(key)	沿主轴返回面板切片
Panel.minor_xs(key)	沿短轴返回面板切片

Binary operator functions

Panel.add(other[, axis])	添加系列和其他元素（二元运算符添加）。
Panel.sub(other[, axis])	减去序列和其他元素（二元运算符子）。
Panel.mul(other[, axis])	系列和其他的乘法，元素（二元运算符mul）。
Panel.div(other[, axis])	系列和其他的浮动划分，元素方式（二元算子truediv）。
Panel.truediv(other[, axis])	系列和其他的浮动划分，元素方式（二元算子truediv）。
Panel.floordiv(other[, axis])	系列和其他的整数除法，元素方式（二元运算符floordiv）。
Panel.mod(other[, axis])	系列和其他的模数，元素方式（二元运算符mod）。
Panel.pow(other[, axis])	系列和其他元素的指数幂（二元运算符pow）。
Panel.radd(other[, axis])	添加系列和其他元素（二元运算符radd）。
Panel.rsub(other[, axis])	减去序列和其他元素（二元运算符rsub）。
Panel.rmul(other[, axis])	系列和其他的乘法，元素（二元运算符rmul）。
Panel.rdiv(other[, axis])	系列和其他的浮动划分，元素方式（二元算子rtruediv）。
Panel.rtruediv(other[, axis])	系列和其他的浮动划分，元素方式（二元算子rtruediv）。
Panel.rfloordiv(other[, axis])	系列和其他的整数除法，元素方式（二元运算符rfloordiv）。
Panel.rmod(other[, axis])	系列和其他的模数，元素方式（二元运算符rmod）。
Panel.rpow(other[, axis])	系列和其他元素的指数幂（二元运算符rpow）。
Panel.lt(other[, axis])	用于比较方法的包装器lt
Panel.gt(other[, axis])	用于比较方法的包装器gt
Panel.le(other[, axis])	用于比较方法的包装器
Panel.ge(other[, axis])	包装用于比较方法ge
Panel.ne(other[, axis])	用于比较方法的包装器ne
Panel.eq(other[, axis])	用于比较方法的包装器eq

Function application, GroupBy

Panel.apply(func[, axis])	沿Panel的轴（或轴）应用功能
Panel.groupby(function[, axis])	在给定轴上分组数据，返回GroupBy对象

Computations / Descriptive Stats

Panel.abs()	返回具有每个元素的绝对数值的Series / DataFrame。
Panel.clip([lower, upper, axis, inplace])	在输入阈值处修剪值。
Panel.clip_lower(threshold[, axis, inplace])	返回值低于阈值截断的输入的副本。
Panel.clip_upper(threshold[, axis, inplace])	输入的返回副本，其值超过给定值（截断）。
Panel.count([axis])	返回请求轴上的观察数。
Panel.cummax([axis, skipna])	返回DataFrame或Series轴上的累积最大值。
Panel.cummin([axis, skipna])	返回DataFrame或Series轴上的累积最小值。
Panel.cumprod([axis, skipna])	通过DataFrame或Series轴返回累积产品。
Panel.cumsum([axis, skipna])	返回DataFrame或Series轴上的累积和。
Panel.max([axis, skipna, level, numeric_only])	此方法返回对象中的最大值。
Panel.mean([axis, skipna, level, numeric_only])	返回请求轴的值的平均值
Panel.median([axis, skipna, level, numeric_only])	返回请求轴的值的中值
Panel.min([axis, skipna, level, numeric_only])	此方法返回对象中的最小值。
Panel.pct_change([periods, fill_method, …])	当前元素和先前元素之间的百分比变化。
Panel.prod([axis, skipna, level, …])	返回请求轴的值的乘积
Panel.sem([axis, skipna, level, ddof, …])	在请求的轴上返回均值的无偏标准误差。
Panel.skew([axis, skipna, level, numeric_only])	返回请求轴的无偏偏差，由N-1归一化
Panel.sum([axis, skipna, level, …])	返回请求轴的值的总和
Panel.std([axis, skipna, level, ddof, …])	返回请求轴上的样本标准偏差。
Panel.var([axis, skipna, level, ddof, …])	在请求的轴上返回无偏差异。

Reindexing / Selection / Label manipulation

Panel.add_prefix(prefix)	带有字符串前缀的前缀标签。
Panel.add_suffix(suffix)	带有字符串后缀的后缀标签。
Panel.drop([labels, axis, index, columns, …])	
Panel.equals(other)	确定两个NDFrame对象是否包含相同的元素。
Panel.filter([items, like, regex, axis])	根据指定索引中的标签设置数据框的行或列。
Panel.first(offset)	用于基于日期偏移量化时间序列数据的初始时段的便捷方法。
Panel.last(offset)	用于基于日期偏移量化时间序列数据的最终时段的便捷方法。
Panel.reindex(*args, **kwargs)	使用可选填充逻辑将Panel转换为新索引，将NA / NaN放置在先前索引中没有值的位置。
Panel.reindex_axis(labels[, axis, method, …])	使用可选的填充逻辑将输入对象符合到新索引，将NA / NaN放置在先前索引中没有值的位置。
Panel.reindex_like(other[, method, copy, …])	将具有匹配索引的对象返回给我自己。
Panel.rename([items, major_axis, minor_axis])	更改轴输入功能。
Panel.sample([n, frac, replace, weights, …])	从对象轴返回随机的项目样本。
Panel.select(crit[, axis])	（DEPRECATED）返回与轴标签匹配条件对应的数据
Panel.take(indices[, axis, convert, is_copy])	沿轴返回给定位置索引中的元素。
Panel.truncate([before, after, axis, copy])	在某个索引值之前和之后截断Series或DataFrame。

Missing data handling

Panel.dropna([axis, how, inplace])	从面板中删除2D，保持传递的轴不变

Reshaping, sorting, transposing

Panel.sort_index([axis, level, ascending, …])	按标签排序对象（沿轴）
Panel.swaplevel([i, j, axis])	在特定轴上的MultiIndex中交换i和j级别
Panel.transpose(*args, **kwargs)	置换面板的尺寸
Panel.swapaxes(axis1, axis2[, copy])	交换轴和交换值轴适当
Panel.conform(frame[, axis])	使输入DataFrame符合选定的轴对。

Combining / joining / merging

Panel.join(other[, how, lsuffix, rsuffix])	在主轴和次轴列上与其他面板连接项目
Panel.update(other[, join, overwrite, …])	使用来自传递的Panel的非NA值或可强制化为Panel的对象来修改面板。

Time series-related

Panel.asfreq(freq[, method, how, normalize, …])	将TimeSeries转换为指定的频率。
Panel.shift([periods, freq, axis])	使用可选的时间频率按期望的周期数移动索引。
Panel.resample(rule[, how, axis, …])	频率转换和时间序列重采样的便捷方法。
Panel.tz_convert(tz[, axis, level, copy])	将tz感知轴转换为目标时区。
Panel.tz_localize(tz[, axis, level, copy, …])	将tz-naive TimeSeries本地化为目标时区。

Serialization / IO / Conversion

Panel.from_dict(data[, intersect, orient, dtype])	从DataFrame对象的dict构造Panel
Panel.to_pickle(path[, compression, protocol])	Pickle（序列化）对象到文件。
Panel.to_excel(path[, na_rep, engine])	将Panel中的每个DataFrame写入单独的Excel工作表
Panel.to_hdf(path_or_buf, key, **kwargs)	使用HDFStore将包含的数据写入HDF5文件。
Panel.to_sparse(*args, **kwargs)	NOT IMPLEMENTED：不要调用此方法，因为Panel对象不支持稀疏，并且会引发错误。
Panel.to_frame([filter_observations])	将宽格式转换为长（堆叠）格式，作为DataFrame，其列是Panel的项目，其索引是由Panel的主轴和次轴组成的MultiIndex。
Panel.to_clipboard([excel, sep])	将对象复制到系统剪贴板。

Index
其中许多方法或其变体可用于包含索引（Series / DataFrame）的对象，并且最有可能在直接调用这些方法之前使用这些方法或变体。

Index	不可变的ndarray实现有序的可切片集。

Attributes

Index.values	将基础数据作为ndarray返回
Index.is_monotonic	is_monotonic_increasing的别名（不建议使用）
Index.is_monotonic_increasing	如果索引是单调递增（仅等于或增加）值，则返回。
Index.is_monotonic_decreasing	如果索引是单调递减（仅等于或递减）值，则返回。
Index.is_unique	如果索引具有唯一值，则返回
Index.has_duplicates	
Index.hasnans	如果我有任何nans，我会回来; 实现各种性能加速
Index.dtype	返回基础数据的dtype对象
Index.dtype_str	返回基础数据的dtype str
Index.inferred_type	返回从值推断出的类型的字符串
Index.is_all_dates	
Index.shape	返回基础数据形状的元组
Index.name	
Index.names	
Index.nbytes	返回基础数据中的字节数
Index.ndim	根据定义1，返回基础数据的维数
Index.size	返回基础数据中的元素数量
Index.empty	
Index.strides	返回基础数据的步幅
Index.itemsize	返回基础数据项的dtype的大小
Index.base	如果共享基础数据的内存，则返回基础对象
Index.T	返回转置，根据定义自我
Index.memory_usage([deep])	内存使用值

Modifying and Computations

Index.all(*args, **kwargs)	返回是否所有元素都为True。
Index.any(*args, **kwargs)	返回任何元素是否为True。
Index.argmin([axis])	返回最小参数索引器的ndarray
Index.argmax([axis])	返回最大参数索引器的ndarray
Index.copy([name, deep, dtype])	制作此对象的副本。
Index.delete(loc)	删除已传递位置（-s）的新索引
Index.drop(labels[, errors])	删除已传递标签列表的新索引
Index.drop_duplicates([keep])	返回索引，删除重复值。
Index.duplicated([keep])	指示重复的索引值。
Index.equals(other)	确定两个Index对象是否包含相同的元素。
Index.factorize([sort, na_sentinel])	将对象编码为枚举类型或分类变量。
Index.identical(other)	与equals类似，但检查其他可比属性是否相等
Index.insert(loc, item)	使新索引在位置插入新项目。
Index.is_(other)	更灵活，更快速的检查，但通过视图工作
Index.is_boolean()	
Index.is_categorical()	检查索引是否包含分类数据。
Index.is_floating()	
Index.is_integer()	
Index.is_interval()	
Index.is_lexsorted_for_tuple(tup)	
Index.is_mixed()	
Index.is_numeric()	
Index.is_object()	
Index.min()	返回索引的最小值。
Index.max()	返回索引的最大值。
Index.reindex(target[, method, level, …])	使用目标值创建索引（根据需要移动/添加/删除值）
Index.rename(name[, inplace])	在索引上设置新名称。
Index.repeat(repeats, *args, **kwargs)	重复索引的元素。
Index.where(cond[, other])	
New in version 0.19.0.

Index.take(indices[, axis, allow_fill, …])	返回索引选择的值的新索引
Index.putmask(mask, value)	返回使用掩码设置的值的新索引
Index.set_names(names[, level, inplace])	在索引上设置新名称。
Index.unique([level])	返回索引中的唯一值。
Index.nunique([dropna])	返回对象中唯一元素的数量。
Index.value_counts([normalize, sort, …])	返回包含唯一值计数的对象。

Missing Values

Index.fillna([value, downcast])	使用指定值填充NA / NaN值
Index.dropna([how])	返回没有NA / NaN值的索引
Index.isna()	检测缺失值。
Index.notna()	检测现有（非缺失）值。

Conversion

Index.astype(dtype[, copy])	使用强制转换为dtypes的值创建索引。
Index.item()	将基础数据的第一个元素作为python标量返回
Index.map(mapper[, na_action])	使用输入对应（字典，系列或函数）映射值。
Index.ravel([order])	返回基础数据的扁平值的ndarray
Index.tolist()	返回值列表。
Index.to_native_types([slicer])	格式化self的指定值并返回它们。
Index.to_series([index, name])	创建一个索引和值等于索引键的系列，该索引键对map用于根据索引返回索引器
Index.to_frame([index])	使用包含索引的列创建DataFrame。
Index.view([cls])

Sorting

Index.argsort(*args, **kwargs)	返回将对索引进行排序的整数索引。
Index.searchsorted(value[, side, sorter])	查找应插入元素以维护顺序的索引。
Index.sort_values([return_indexer, ascending])	返回索引的排序副本。

Time-specific operations¶

Index.shift([periods, freq])	按所需的时间频率增量数移动索引。

Combining / joining / set operations

Index.append(other)	一起附加索引选项的集合
Index.join(other[, how, level, …])	这是一种内部非公开方法
Index.intersection(other)	形成两个Index对象的交集。
Index.union(other)	如果可能，形成两个Index对象的联合和排序。
Index.difference(other)	返回包含索引中不在其他元素中的元素的新索引。
Index.symmetric_difference(other[, result_name])	计算两个Index对象的对称差异。

Selecting

Index.asof(label)	对于排序索引，返回最新标签，包括传递的标签。
Index.asof_locs(where, mask)	其中：timestamps数组mask：数据不是NA的布尔数组
Index.contains(key)	如果此键在索引中，则返回布尔值
Index.get_duplicates()	（DEPRECATED）提取重复的索引元素。
Index.get_indexer(target[, method, limit, …])	给定当前索引计算新索引的索引器和掩码。
Index.get_indexer_for(target, **kwargs)	即使在非唯一时也保证返回索引器这将调整到get_indexer或get_indexer_nonunique
Index.get_indexer_non_unique(target)	给定当前索引计算新索引的索引器和掩码。
Index.get_level_values(level)	返回请求级别的值索引，等于索引的长度。
Index.get_loc(key[, method, tolerance])	获取所请求标签的整数位置，切片或布尔掩码。
Index.get_slice_bound(label, side, kind)	计算与给定标签对应的切片边界。
Index.get_value(series, key)	从1维ndarray快速查找值。
Index.get_values()	将索引数据作为numpy.ndarray返回。
Index.set_value(arr, key, value)	从1维ndarray快速查找值。
Index.isin(values[, level])	返回一个布尔数组，其中索引值为value。
Index.slice_indexer([start, end, step, kind])	对于有序或唯一索引，请计算输入标签和步骤的切片索引器。
Index.slice_locs([start, end, step, kind])	计算输入标签的切片位置。

Numeric Index
RangeIndex	不可变指数实现单调整数范围。
Int64Index	不可变的ndarray实现有序的可切片集。
UInt64Index	不可变的ndarray实现有序的可切片集。
Float64Index	不可变的ndarray实现有序的可切片集。
RangeIndex.from_range(data[, name, dtype])	从范围（py3）或xrange（py2）对象创建RangeIndex

CategoricalIndex
CategoricalIndex	不可变索引实现有序的可切片集。

Categorical Components

CategoricalIndex.codes	
CategoricalIndex.categories	
CategoricalIndex.ordered	
CategoricalIndex.rename_categories(*args, …)	重命名类别。
CategoricalIndex.reorder_categories(*args, …)	重新排序new_categories中指定的类别。
CategoricalIndex.add_categories(*args, **kwargs)	添加新类别。
CategoricalIndex.remove_categories(*args, …)	删除指定的类别。
CategoricalIndex.remove_unused_categories(…)	删除未使用的类别。
CategoricalIndex.set_categories(*args, **kwargs)	将类别设置为指定的new_categories。
CategoricalIndex.as_ordered(*args, **kwargs)	设置要排序的分类
CategoricalIndex.as_unordered(*args, **kwargs)	将Categorical设置为无序
CategoricalIndex.map(mapper)	使用输入对应（字典，系列或函数）映射值。

IntervalIndex
IntervalIndex	不可变索引实现有序的可切片集。

IntervalIndex Components

IntervalIndex.from_arrays(left, right[, …])	从定义左边界和右边界的两个数组构造。
IntervalIndex.from_tuples(data[, closed, …])	从元组的列表/数组构造IntervalIndex
IntervalIndex.from_breaks(breaks[, closed, …])	从一组拆分构造一个IntervalIndex
IntervalIndex.contains(key)	返回一个布尔值，指示键是否在索引中
IntervalIndex.left	将IntervalIndex中每个Interval的左端点作为索引返回
IntervalIndex.right	将IntervalIndex中每个Interval的右端点作为索引返回
IntervalIndex.mid	将IntervalIndex中每个Interval的中点作为索引返回
IntervalIndex.closed	是否在左侧，右侧，两者或两者都关闭间隔
IntervalIndex.length	返回一个索引，其中的条目表示IntervalIndex中每个Interval的长度
IntervalIndex.values	将IntervalIndex的数据作为Interval对象的numpy数组返回（使用dtype ='object'）
IntervalIndex.is_non_overlapping_monotonic	如果IntervalIndex不重叠（没有间隔共享点）并且是单调递增或单调递减，则返回True，否则返回False
IntervalIndex.get_loc(key[, method])	获取所请求标签的整数位置，切片或布尔掩码。
IntervalIndex.get_indexer(target[, method, …])	给定当前索引计算新索引的索引器和掩码。

MultiIndex
MultiIndex	用于pandas对象的多级或分层索引对象
IndexSlice	创建一个对象以更轻松地执行多索引切片

MultiIndex Attributes

MultiIndex.names	MultiIndex中的级别名称
MultiIndex.levels	
MultiIndex.labels	
MultiIndex.nlevels	此MultiIndex中的整数级别。
MultiIndex.levshape	每个级别长度的元组。

MultiIndex Components

MultiIndex.set_levels(levels[, level, …])	在MultiIndex上设置新级别。
MultiIndex.set_labels(labels[, level, …])	在MultiIndex上设置新标签。
MultiIndex.to_hierarchical(n_repeat[, n_shuffle])	返回重新整形的MultiIndex以符合n_repeat和n_shuffle给出的形状。
MultiIndex.to_frame([index])	使用MultiIndex的级别作为列创建DataFrame。
MultiIndex.is_lexsorted()	如果标签按字典顺序排序，则返回True
MultiIndex.sortlevel([level, ascending, …])	按要求的级别对MultiIndex进行排序。
MultiIndex.droplevel([level])	已删除请求级别的返回索引。
MultiIndex.swaplevel([i, j])	交换等级i与等级j。
MultiIndex.reorder_levels(order)	使用输入顺序重新排列级别。
MultiIndex.remove_unused_levels()	从当前删除未使用的级别创建一个新的MultiIndex，这意味着它们不会在标签中表示
MultiIndex.unique([level])	返回索引中的唯一值。

DatetimeIndex
DatetimeIndex	datetime64数据的不可变ndarray，内部表示为int64，可以装入Timestamp对象，这些对象是datetime的子类，并携带元数据，如频率信息。

Time/Date Components

DatetimeIndex.year	日期时间
DatetimeIndex.month	月份为1月= 1，12月= 12
DatetimeIndex.day	日期时间的日子
DatetimeIndex.hour	日期时间
DatetimeIndex.minute	日期时间的分钟
DatetimeIndex.second	日期时间的秒数
DatetimeIndex.microsecond	日期时间的微秒
DatetimeIndex.nanosecond	日期时间的纳秒
DatetimeIndex.date	返回numpy数组的python datetime.date对象（即没有时区信息的Timestamps的日期部分）。
DatetimeIndex.time	返回datetime.time的numpy数组。
DatetimeIndex.dayofyear	一年中的序数日
DatetimeIndex.weekofyear	一年中的一周序数
DatetimeIndex.week	一年中的一周序数
DatetimeIndex.dayofweek	星期一= 0，星期日= 6的星期几
DatetimeIndex.weekday	星期一= 0，星期日= 6的星期几
DatetimeIndex.quarter	日期的四分之一
DatetimeIndex.tz	
DatetimeIndex.freq	如果已设置，则返回频率对象，否则返回None
DatetimeIndex.freqstr	如果设置了频率对象，则将其作为字符串返回，否则为None
DatetimeIndex.is_month_start	逻辑指示是否每月的第一天（由频率定义）
DatetimeIndex.is_month_end	指示日期是否是该月的最后一天。
DatetimeIndex.is_quarter_start	指示日期是否是一个季度的第一天。
DatetimeIndex.is_quarter_end	指示日期是否是一个季度的最后一天。
DatetimeIndex.is_year_start	指明日期是否是一年的第一天。
DatetimeIndex.is_year_end	指明日期是一年中的最后一天。
DatetimeIndex.is_leap_year	布尔指示符，如果日期属于闰年。
DatetimeIndex.inferred_freq	尝试返回表示由infer_freq生成的频率猜测的字符串。

Selecting¶

DatetimeIndex.indexer_at_time(time[, asof])	返回特定时刻的索引值的索引位置（例如
DatetimeIndex.indexer_between_time(…[, …])	返回值的特定时间之间的值的索引位置（例如，9：00-9：30AM）。

Time-specific operations

DatetimeIndex.normalize()	将时间转换为午夜。
DatetimeIndex.strftime(date_format)	使用指定的date_format转换为Index。
DatetimeIndex.snap([freq])	将时间戳记录到最近出现的频率
DatetimeIndex.tz_convert(tz)	将tz-aware DatetimeIndex从一个时区转换为另一个时区。
DatetimeIndex.tz_localize(tz[, ambiguous, …])	将tz-naive DatetimeIndex本地化为tz-aware DatetimeIndex。
DatetimeIndex.round(freq, *args, **kwargs)	将数据舍入到指定的频率。
DatetimeIndex.floor(freq)	将数据置于指定的频率。
DatetimeIndex.ceil(freq)	将数据ceil到指定的频率。
DatetimeIndex.month_name([locale])	返回具有指定语言环境的DateTimeIndex的月份名称。
DatetimeIndex.day_name([locale])	返回具有指定语言环境的DateTimeIndex的日期名称。

Conversion

DatetimeIndex.to_period([freq])	以特定频率转换为PeriodIndex。
DatetimeIndex.to_perioddelta(freq)	计算索引值与指定频率下转换为periodIndex的索引之间差异的TimedeltaIndex。
DatetimeIndex.to_pydatetime()	返回DatetimeIndex作为datetime.datetime对象的对象ndarray
DatetimeIndex.to_series([keep_tz, index, name])	创建一个索引和值等于索引键的系列，该索引键对map用于根据索引返回索引器
DatetimeIndex.to_frame([index])	使用包含索引的列创建DataFrame。

TimedeltaIndex
TimedeltaIndex	timedelta64数据的不可变ndarray，内部表示为int64，可以装入timedelta对象

Components

TimedeltaIndex.days	每个元素的天数。
TimedeltaIndex.seconds	每个元素的秒数（> = 0且小于1天）。
TimedeltaIndex.nanoseconds	每个元素的纳秒数（> = 0且小于1微秒）。
TimedeltaIndex.components	返回Timedeltas的组件（天，小时，分钟，秒，毫秒，微秒，纳秒）的数据帧。
TimedeltaIndex.inferred_freq	尝试返回表示由infer_freq生成的频率猜测的字符串。

Conversion

TimedeltaIndex.to_pytimedelta()	返回TimedeltaIndex作为datetime.timedelta对象的对象ndarray
TimedeltaIndex.to_series([index, name])	创建一个索引和值等于索引键的系列，该索引键对map用于根据索引返回索引器
TimedeltaIndex.round(freq, *args, **kwargs)	将数据舍入到指定的频率。
TimedeltaIndex.floor(freq)	将数据置于指定的频率。
TimedeltaIndex.ceil(freq)	将数据ceil到指定的频率。
TimedeltaIndex.to_frame([index])	使用包含索引的列创建DataFrame。

PeriodIndex
PeriodIndex	不可变的ndarray持有序数值，表示特定的时间段，如特定的年，季度，月等。

Attributes

PeriodIndex.day	这段时期
PeriodIndex.dayofweek	星期一= 0，星期日= 6的星期几
PeriodIndex.dayofyear	一年中的序数日
PeriodIndex.days_in_month	本月的天数
PeriodIndex.daysinmonth	本月的天数
PeriodIndex.end_time	
PeriodIndex.freq	如果已设置，则返回频率对象，否则返回None
PeriodIndex.freqstr	如果设置了频率对象，则将其作为字符串返回，否则为None
PeriodIndex.hour	这段时间
PeriodIndex.is_leap_year	逻辑指示日期是否属于闰年
PeriodIndex.minute	这段时间的一分钟
PeriodIndex.month	月份为1月= 1，12月= 12
PeriodIndex.quarter	日期的四分之一
PeriodIndex.qyear	
PeriodIndex.second	第二个时期
PeriodIndex.start_time	
PeriodIndex.week	一年中的一周序数
PeriodIndex.weekday	星期一= 0，星期日= 6的星期几
PeriodIndex.weekofyear	一年中的一周序数
PeriodIndex.year	这一年的一年

Methods

PeriodIndex.asfreq([freq, how])	将PeriodIndex转换为指定的频率freq。
PeriodIndex.strftime(date_format)	使用指定的date_format转换为Index。
PeriodIndex.to_timestamp([freq, how])	转换为DatetimeIndex
PeriodIndex.tz_convert(tz)	将tz-aware DatetimeIndex从一个时区转换为另一个时区（使用pytz / dateutil）
PeriodIndex.tz_localize(tz[, ambiguous])	将tz-naive DatetimeIndex本地化为给定时区（使用pytz / dateutil），或从tz-aware DatetimeIndex中删除时区

Scalars¶

Period

Period	代表一段时间

Attributes

Period.day	获取某个时段所在月份的某一天。
Period.dayofweek	返回星期几。
Period.dayofyear	返回一年中的某一天。
Period.days_in_month	获取此期间所在月份的总天数。
Period.daysinmonth	获取该期间所在月份的总天数。
Period.end_time	
Period.freq	
Period.freqstr	
Period.hour	获取期间的小时组成部分。
Period.is_leap_year	
Period.minute	获取期间的小时部分。
Period.month	
Period.ordinal	
Period.quarter	
Period.qyear	
Period.second	获取期间的第二个组成部分。
Period.start_time	获取期间开始的时间戳。
Period.week	获取给定期间的一年中的一周。
Period.weekday	
Period.weekofyear	
Period.year	

Methods

Period.asfreq	将周期转换为所需频率，在间隔的开始或结束时
Period.now	
Period.strftime	返回Period的字符串表示形式，具体取决于所选的fmt。
Period.to_timestamp	将Period的Timestamp表示返回到Period的指定末尾（how）的目标频率

Timestamp

Timestamp	Pandas替换datetime.datetime

Properties

Timestamp.asm8	
Timestamp.day	
Timestamp.dayofweek	
Timestamp.dayofyear	
Timestamp.days_in_month	
Timestamp.daysinmonth	
Timestamp.fold	
Timestamp.hour	
Timestamp.is_leap_year	
Timestamp.is_month_end	
Timestamp.is_month_start	
Timestamp.is_quarter_end	
Timestamp.is_quarter_start	
Timestamp.is_year_end	
Timestamp.is_year_start	
Timestamp.max	
Timestamp.microsecond	
Timestamp.min	
Timestamp.minute	
Timestamp.month	
Timestamp.nanosecond	
Timestamp.quarter	
Timestamp.resolution	
Timestamp.second	
Timestamp.tz	Alias for tzinfo
Timestamp.tzinfo	
Timestamp.value	
Timestamp.week	
Timestamp.weekofyear	
Timestamp.year	

Methods

Timestamp.astimezone	将tz-aware Timestamp转换为另一个时区。
Timestamp.ceil	返回一个新的时间戳，该时间戳已通过此决议
Timestamp.combine(date, time)	date，time - > datetime，具有相同的日期和时间字段
Timestamp.ctime	返回ctime（）样式字符串。
Timestamp.date	返回具有相同年，月和日的日期对象。
Timestamp.day_name	返回具有指定语言环境的时间戳的日期名称。
Timestamp.dst	返回self.tzinfo.dst（自我）。
Timestamp.floor	返回一个覆盖此分辨率的新时间戳
Timestamp.freq	
Timestamp.freqstr	
Timestamp.fromordinal(ordinal[, freq, tz])	传递了序数，翻译并转换为ts音符：根据定义，序数本身不能有任何tz信息
Timestamp.fromtimestamp(ts)	timestamp[, tz] -> tz从POSIX时间戳开始的本地时间。
Timestamp.isocalendar	返回包含ISO年份，周数和工作日的3元组。
Timestamp.isoformat	
Timestamp.isoweekday	返回日期所代表的星期几。
Timestamp.month_name	返回具有指定语言环境的Timestamp的月份名称。
Timestamp.normalize	将时间戳标准化为午夜，保留tz信息。
Timestamp.now([tz])	返回表示tz本地当前时间的新Timestamp对象。
Timestamp.replace	实现datetime.replace，处理纳秒
Timestamp.round	将时间戳舍入为指定的分辨率
Timestamp.strftime	format - > strftime（）样式字符串。
Timestamp.strptime	string，format - >从字符串解析的新日期时间（如time.strptime（））。
Timestamp.time	同时返回时间对象但是tzinfo = None。
Timestamp.timestamp	将POSIX时间戳返回为float。
Timestamp.timetuple	返回时间元组，与time.localtime（）兼容。
Timestamp.timetz	同时返回时间对象和tzinfo。
Timestamp.to_datetime64	返回具有'ns'精度的numpy.datetime64对象
Timestamp.to_julian_date	将TimeStamp转换为Julian日期。
Timestamp.to_period	返回此时间戳为观察值的时段。
Timestamp.to_pydatetime	将Timestamp对象转换为本机Python datetime对象。
Timestamp.today(cls[, tz])	返回当地时区的当前时间。
Timestamp.toordinal	返回预感格里高利序数。
Timestamp.tz_convert	将tz-aware Timestamp转换为另一个时区。
Timestamp.tz_localize	将天真时间戳转换为本地时区，或从tz感知时间戳中删除时区。
Timestamp.tzname	返回self.tzinfo.tzname（个体经营）。
Timestamp.utcfromtimestamp(ts)	从POSIX时间戳构造一个天真的UTC日期时间。
Timestamp.utcnow()	返回表示UTC日期和时间的新时间戳。
Timestamp.utcoffset	返回self.tzinfo.utcoffset（个体经营）。
Timestamp.utctimetuple	返回UTC时间元组，与time.localtime（）兼容。
Timestamp.weekday	返回日期所代表的星期几。

Interval¶

Interval	不可变对象实现Interval，有界切片状间隔。

Properties

Interval.closed	是否在左侧，右侧，两侧或两者都关闭间隔
Interval.closed_left	检查左侧是否关闭间隔。
Interval.closed_right	检查右侧是否关闭间隔。
Interval.left	左边界限
Interval.length	返回Interval的长度
Interval.mid	返回间隔的中点
Interval.open_left	检查左侧是否打开间隔。
Interval.open_right	检查右侧是否打开间隔。
Interval.right	右边界限

Timedelta

Timedelta	表示持续时间，两个日期或时间之间的差异。

Properties

Timedelta.asm8	返回我自己的numpy timedelta64数组视图
Timedelta.components	返回与NamedTuple类似的组件
Timedelta.days	天数。
Timedelta.delta	以纳秒（ns）为单位返回timedelta，以获得内部兼容性。
Timedelta.freq	
Timedelta.is_populated	
Timedelta.max	
Timedelta.microseconds	微秒数（> = 0且小于1秒）。
Timedelta.min	
Timedelta.nanoseconds	返回纳秒数（n），其中0 <= n <1微秒。
Timedelta.resolution	返回表示我们拥有的最低分辨率的字符串
Timedelta.seconds	秒数（> = 0且不到1天）。
Timedelta.value	
Timedelta.view	数组视图compat

Methods

Timedelta.ceil	返回一个新的Timedelta以此决议
Timedelta.floor	返回一个新的Timedelta，落在这个分辨率上
Timedelta.isoformat	格式Timedelta为ISO 8601持续时间，如P [n] Y [n] M [n] DT [n] H [n] M [n] S，其中[n] s由值替换。
Timedelta.round	将Timedelta四舍五入到指定的分辨率
Timedelta.to_pytimedelta	返回一个实际的datetime.timedelta对象注释：如果有的话，我们将失去纳秒分辨率
Timedelta.to_timedelta64	返回具有'ns'精度的numpy.timedelta64对象
Timedelta.total_seconds	timedelta的总持续时间，以秒为单位（以ns精度计）

Frequencies
to_offset(freq)	从字符串或元组表示或datetime.timedelta对象返回DateOffset对象

窗口
滚动对象由.rolling调用返回：pandas.DataFrame.rolling（），pandas.Series.rolling（），
     扩展对象由.expanding调用返回：pandas.DataFrame.expanding（），
         pandas.Series.expanding（）等.ewm调用返回EWM对象：pandas.DataFrame.ewm（），
             pandas.Series.ewm（）等

Standard moving window functions

Rolling.count()	窗口内任何非NaN观测值的滚动计数。
Rolling.sum(*args, **kwargs)	计算给定DataFrame或Series的滚动总和。
Rolling.mean(*args, **kwargs)	计算值的滚动平均值。
Rolling.median(**kwargs)	计算滚动中位数。
Rolling.var([ddof])	计算无偏滚动方差。
Rolling.std([ddof])	计算滚动标准偏差。
Rolling.min(*args, **kwargs)	计算滚动最小值。
Rolling.max(*args, **kwargs)	滚动最大值
Rolling.corr([other, pairwise])	滚动样本相关性
Rolling.cov([other, pairwise, ddof])	滚动样本协方差
Rolling.skew(**kwargs)	无偏见的滚动偏度
Rolling.kurt(**kwargs)	计算无偏滚动峰度。
Rolling.apply(func[, raw, args, kwargs])	滚动功能适用
Rolling.aggregate(arg, *args, **kwargs)	使用指定轴上的一个或多个操作进行聚合。
Rolling.quantile(quantile[, interpolation])	滚动分位数。
Window.mean(*args, **kwargs)	计算值的窗口均值。
Window.sum(*args, **kwargs)	计算给定DataFrame或Series的窗口总和。

Standard expanding window functions

Expanding.count(**kwargs)	窗口内任何非NaN观测值的扩展计数。
Expanding.sum(*args, **kwargs)	计算给定DataFrame或Series的扩展和。
Expanding.mean(*args, **kwargs)	计算值的扩展平均值。
Expanding.median(**kwargs)	计算扩展中位数。
Expanding.var([ddof])	计算无偏扩展方差。
Expanding.std([ddof])	计算扩展标准偏差。
Expanding.min(*args, **kwargs)	计算扩展的最小值。
Expanding.max(*args, **kwargs)	扩大最大化
Expanding.corr([other, pairwise])	扩大样本相关性
Expanding.cov([other, pairwise, ddof])	扩展样本协方差
Expanding.skew(**kwargs)	不偏不倚地扩大偏斜
Expanding.kurt(**kwargs)	计算无偏扩张峰度。
Expanding.apply(func[, raw, args, kwargs])	扩展功能适用
Expanding.aggregate(arg, *args, **kwargs)	使用指定轴上的一个或多个操作进行聚合。
Expanding.quantile(quantile[, interpolation])	扩大分位数。

Exponentially-weighted moving window functions

EWM.mean(*args, **kwargs)	指数加权移动平均线
EWM.std([bias])	指数加权移动stddev
EWM.var([bias])	指数加权移动方差
EWM.corr([other, pairwise])	指数加权样本相关
EWM.cov([other, pairwise, bias])	指数加权样本协方差

GroupBy
Groupby调用返回GroupBy对象：pandas.DataFrame.groupby（），pandas.Series.groupby（）等。

Indexing, iteration

GroupBy.__iter__()	Groupby迭代器
GroupBy.groups	dict {group name -> group labels}
GroupBy.indices	dict {group name -> group indices}
GroupBy.get_group(name[, obj])	从提供名称的组构造NDFrame
Grouper([key, level, freq, axis, sort])	Grouper允许用户通过指令为目标对象指定组

Function application

GroupBy.apply(func, *args, **kwargs)	分组应用函数func并将结果组合在一起。
GroupBy.aggregate(func, *args, **kwargs)	
GroupBy.transform(func, *args, **kwargs)	
GroupBy.pipe(func, *args, **kwargs)	将带有参数的函数func应用于此GroupBy对象并返回函数的结果。

Computations / Descriptive Stats

GroupBy.all([skipna])	如果组中的所有值都是真实的，则返回True，否则返回False
GroupBy.any([skipna])	如果组中的任何值是真实的，则返回True，否则返回False
GroupBy.bfill([limit])	向后填充值
GroupBy.count()	计算组的计数，不包括缺失值
GroupBy.cumcount([ascending])	将每个组中的每个项目编号从0到该组的长度 - 1。
GroupBy.ffill([limit])	向前填充值
GroupBy.first(**kwargs)	首先计算组值
GroupBy.head([n])	返回每组的前n行。
GroupBy.last(**kwargs)	计算最后一组值
GroupBy.max(**kwargs)	计算组值的最大值
GroupBy.mean(*args, **kwargs)	计算组的平均值，不包括缺失值
GroupBy.median(**kwargs)	计算组的中位数，排除缺失值
GroupBy.min(**kwargs)	计算组值的最小值
GroupBy.ngroup([ascending])	将每个组的编号从0到组的数量 - 1。
GroupBy.nth(n[, dropna])	如果n是int，则从每个组获取第n行;如果n是int列表，则从行的子集获取。
GroupBy.ohlc()	计算值的总和，不包括缺失值对于多个分组，结果索引将是MultiIndex
GroupBy.prod(**kwargs)	计算组值的产品
GroupBy.rank([method, ascending, na_option, …])	提供每个组中的值的等级。
GroupBy.pct_change([periods, fill_method, …])	计算每个值的pct_change到组中的上一个条目
GroupBy.size()	计算组大小
GroupBy.sem([ddof])	计算组平均值的标准误差，排除缺失值
GroupBy.std([ddof])	计算组的标准偏差，不包括缺失值
GroupBy.sum(**kwargs)	计算组值的总和
GroupBy.var([ddof])	计算组的方差，排除缺失值
GroupBy.tail([n])	返回每组的最后n行

SeriesGroupBy和DataFrameGroupBy对象中可以使用以下方法，但可能略有不同，
通常是因为DataFrameGroupBy版本通常允许指定axis参数，
并且通常是指示是否将应用程序限制为特定数据类型的列的参数

DataFrameGroupBy.agg(arg, *args, **kwargs)	使用指定轴上的一个或多个操作进行聚合。
DataFrameGroupBy.all([skipna])	如果组中的所有值都是真实的，则返回True，否则返回False
DataFrameGroupBy.any([skipna])	如果组中的任何值是真实的，则返回True，否则返回False
DataFrameGroupBy.bfill([limit])	向后填充值
DataFrameGroupBy.corr	计算列的成对相关性，不包括NA / null值
DataFrameGroupBy.count()	计算组的计数，不包括缺失值
DataFrameGroupBy.cov	计算列的成对协方差，不包括NA / null值。
DataFrameGroupBy.cummax([axis])	每组累积最大值
DataFrameGroupBy.cummin([axis])	每组累积最小值
DataFrameGroupBy.cumprod([axis])	每组的累积产品
DataFrameGroupBy.cumsum([axis])	每组的累计金额
DataFrameGroupBy.describe(**kwargs)	生成描述性统计数据，总结数据集分布的集中趋势，分散和形状，不包括NaN值。
DataFrameGroupBy.diff	第一个离散的元素差异。
DataFrameGroupBy.ffill([limit])	向前填充值
DataFrameGroupBy.fillna	使用指定的方法填充NA / NaN值
DataFrameGroupBy.filter(func[, dropna])	返回DataFrame的副本，不包括不满足func指定的布尔标准的组中的元素。
DataFrameGroupBy.hist	制作DataFrame的直方图。
DataFrameGroupBy.idxmax	返回请求轴上第一次出现最大值的索引。
DataFrameGroupBy.idxmin	返回首次出现最小请求轴的索引。
DataFrameGroupBy.mad	返回请求轴的值的平均绝对偏差
DataFrameGroupBy.pct_change([periods, …])	计算每个值的pct_change到组中的上一个条目
DataFrameGroupBy.plot	实现groupby对象的.plot属性的类
DataFrameGroupBy.quantile	在请求的轴上返回给定分位数的值，即la numpy.percentile。
DataFrameGroupBy.rank([method, ascending, …])	提供每个组中的值的等级。
DataFrameGroupBy.resample(rule, *args, **kwargs)	使用TimeGrouper时提供重新采样返回附加了重新采样器的新石斑鱼
DataFrameGroupBy.shift([periods, freq, axis])	按周期观察移动每组
DataFrameGroupBy.size()	计算组大小
DataFrameGroupBy.skew	返回请求轴的无偏偏差，由N-1归一化
DataFrameGroupBy.take	沿轴返回给定位置索引中的元素。
DataFrameGroupBy.tshift	如果可用，使用索引的频率来移动时间索引。

以下方法仅适用于SeriesGroupBy对象。

SeriesGroupBy.nlargest	返回最大的n个元素。
SeriesGroupBy.nsmallest	返回最小的n个元素。
SeriesGroupBy.nunique([dropna])	返回组中唯一元素的数量
SeriesGroupBy.unique	返回Series对象的唯一值。
SeriesGroupBy.value_counts([normalize, …])	
SeriesGroupBy.is_monotonic_increasing	如果对象中的值是monotonic_increasing，则返回布尔值
SeriesGroupBy.is_monotonic_decreasing	如果对象中的值是monotonic_decreasing，则返回布尔值

以下方法仅适用于DataFrameGroupBy对象。

DataFrameGroupBy.corrwith	计算两个DataFrame对象的行或列之间的成对关联。
DataFrameGroupBy.boxplot([subplots, column, …])	从DataFrameGroupBy数据制作箱形图。

Resampling
重新采样器对象由重新采样调用返回：pandas.DataFrame.resample（），pandas.Series.resample（）。

Indexing, iteration

Resampler.__iter__()	Groupby迭代器
Resampler.groups	dict {group name -> group labels}
Resampler.indices	dict {group name -> group indices}
Resampler.get_group(name[, obj])	从提供名称的组构造NDFrame

Function application

Resampler.apply(arg, *args, **kwargs)	使用指定轴上的一个或多个操作进行聚合。
Resampler.aggregate(arg, *args, **kwargs)	使用指定轴上的一个或多个操作进行聚合。
Resampler.transform(arg, *args, **kwargs)	调用函数在每个组上生成类似索引的Series，并返回带有转换值的Series
Resampler.pipe(func, *args, **kwargs)	将带有参数的函数func应用于此Resampler对象并返回函数的结果。

Upsampling

Resampler.ffill([limit])	向前填充值
Resampler.backfill([limit])	向后填充重新采样数据中的新缺失值。
Resampler.bfill([limit])	向后填充重新采样数据中的新缺失值。
Resampler.pad([limit])	向前填充值
Resampler.nearest([limit])	从中心开始用最近邻居填充值
Resampler.fillna(method[, limit])	填写上采样引入的缺失值。
Resampler.asfreq([fill_value])	返回新频率的值，基本上是一个reindex
Resampler.interpolate([method, axis, limit, …])	根据不同的方法插值。

Computations / Descriptive Stats

Resampler.count([_method])	计算组的计数，不包括缺失值
Resampler.nunique([_method])	返回组中唯一元素的数量
Resampler.first([_method])	首先计算组值
Resampler.last([_method])	计算最后一组值
Resampler.max([_method])	计算组值的最大值
Resampler.mean([_method])	计算组的平均值，不包括缺失值
Resampler.median([_method])	计算组的中位数，排除缺失值
Resampler.min([_method])	计算组值的最小值
Resampler.ohlc([_method])	计算值的总和，不包括缺失值对于多个分组，结果索引将是MultiIndex
Resampler.prod([_method, min_count])	计算组值的产品
Resampler.size()	计算组大小
Resampler.sem([_method])	计算组平均值的标准误差，排除缺失值
Resampler.std([ddof])	计算组的标准偏差，不包括缺失值
Resampler.sum([_method, min_count])	计算组值的总和
Resampler.var([ddof])	计算组的方差，排除缺失值

Style
样式对象由pandas.DataFrame.style返回。

Styler Constructor

Styler(data[, precision, table_styles, …])	根据HTML和CSS的数据帮助设置DataFrame或Series的样式。
Styler.from_custom_template(searchpath, name)	用于使用自定义模板和Jinja环境创建Styler的子类的工厂函数。

Styler Attributes

Styler.env	
Styler.template	
Styler.loader

Style Application

Styler.apply(func[, axis, subset])	按列，按行或按行应用函数，使用结果更新HTML表示。
Styler.applymap(func[, subset])	元素应用函数，使用结果更新HTML表示。
Styler.where(cond, value[, other, subset])	元素应用函数，使用根据函数的返回值选择的样式更新HTML表示。
Styler.format(formatter[, subset])	格式化单元格的文本显示值。
Styler.set_precision(precision)	设置用于渲染的精度。
Styler.set_table_styles(table_styles)	在Styler上设置表格样式。
Styler.set_table_attributes(attributes)	设置表属性。
Styler.set_caption(caption)	在样式器上设置标题
Styler.set_properties([subset])	用于设置一个或多个非数据相关属性或每个单元的便捷方法。
Styler.set_uuid(uuid)	为Styler设置uuid。
Styler.clear()	“重置”样式器，删除任何以前应用的样式。

Builtin Styles

Styler.highlight_max([subset, color, axis])	通过着色背景突出显示最大值
Styler.highlight_min([subset, color, axis])	通过着色背景突出显示最小值
Styler.highlight_null([null_color])	为缺失值着色背景null_color。
Styler.background_gradient([cmap, low, …])	根据每列（可选行）中的数据为渐变中的背景着色。
Styler.bar([subset, axis, color, width, align])	将背景颜色着色为与每列中的值成比例。

Style Export and Import

Styler.render(**kwargs)	将构建的样式呈现为HTML
Styler.export()	导出要应用于当前Styler的样式。
Styler.use(styles)	在当前Styler上设置样式，可能使用Styler.export中的样式。
Styler.to_excel(excel_writer[, sheet_name, …])	将Styler写入Excel工作表

Plotting
pandas.plotting模块中包含以下函数。

andrews_curves(frame, class_column[, ax, …])	生成安德鲁斯曲线的matplotlib图，用于可视化多元数据的聚类。
bootstrap_plot(series[, fig, size, samples])	关于均值，中位数和中位数统计的Bootstrap图。
deregister_matplotlib_converters()	删除pandas的格式化程序和转换器
lag_plot(series[, lag, ax])	时间序列的滞后图。
parallel_coordinates(frame, class_column[, …])	平行坐标绘图。
radviz(frame, class_column[, ax, color, …])	在2D中绘制多维数据集。
register_matplotlib_converters([explicit])	使用matplotlib注册Pandas格式化程序和转换器
scatter_matrix(frame[, alpha, figsize, ax, …])	绘制散点图矩阵。

General utility functions

Working with options

describe_option(pat[, _print_desc])	打印一个或多个已注册选项的说明。
reset_option(pat)	将一个或多个选项重置为其默认值。
get_option(pat)	检索指定选项的值。
set_option(pat, value)	设置指定选项的值。
option_context(*args)	上下文管理器临时设置with语句上下文中的选项。

Testing functions

testing.assert_frame_equal(left, right[, …])	检查左右DataFrame是否相等。
testing.assert_series_equal(left, right[, …])	检查左右系列是否相等。
testing.assert_index_equal(left, right[, …])	检查左右索引是否相等。

Exceptions and warnings

errors.DtypeWarning从文件中读取列中不同dtypes时引发的警告。
errors.EmptyDataError	遇到空数据或标头时，在pd.read_csv（由C和Python引擎引发）中抛出的异常。
errors.OutOfBoundsDatetime	
errors.ParserError	pd.read_csv中遇到的错误引发的异常。
errors.ParserWarning	读取不使用默认“c”解析器的文件时引发警告。
errors.PerformanceWarning	出现可能的性能影响时发出警告。
errors.UnsortedIndexError	尝试获取MultiIndex切片时出错，并且索引尚未被lexsorted。
errors.UnsupportedFunctionCall	尝试在pandas对象上调用numpy函数时引发异常，但该对象不支持该函数，例如

Data types related functionality

api.types.union_categoricals(to_union[, …])	结合列表类似类别，联合类别。
api.types.infer_dtype	有效地推断传递的val或类似列表的数组的类型。
api.types.pandas_dtype(dtype)	将输入转换为仅pandas的dtype对象或numpy dtype对象。

Dtype introspection

api.types.is_bool_dtype(arr_or_dtype)	检查提供的数组或dtype是否为布尔dtype。
api.types.is_categorical_dtype(arr_or_dtype)	检查类似数组或dtype是否属于Categorical dtype。
api.types.is_complex_dtype(arr_or_dtype)	检查提供的数组或dtype是否为复杂的dtype。
api.types.is_datetime64_any_dtype(arr_or_dtype)	检查提供的数组或dtype是否为datetime64 dtype。
api.types.is_datetime64_dtype(arr_or_dtype)	检查数组类型或dtype是否为datetime64 dtype。
api.types.is_datetime64_ns_dtype(arr_or_dtype)	检查提供的数组或dtype是否为datetime64 [ns] dtype。
api.types.is_datetime64tz_dtype(arr_or_dtype)	检查数组类型或dtype是否为DatetimeTZDtype dtype。
api.types.is_extension_type(arr)	检查类似数组是否是pandas扩展类实例。
api.types.is_float_dtype(arr_or_dtype)	检查提供的数组或dtype是否为float dtype。
api.types.is_int64_dtype(arr_or_dtype)	检查提供的数组或dtype是否为int64 dtype。
api.types.is_integer_dtype(arr_or_dtype)	检查提供的数组或dtype是否为整数dtype。
api.types.is_interval_dtype(arr_or_dtype)	检查数组类型或dtype是否为Interval dtype。
api.types.is_numeric_dtype(arr_or_dtype)	检查提供的数组或dtype是否为数字dtype。
api.types.is_object_dtype(arr_or_dtype)	检查数组类型或dtype是否为对象dtype。
api.types.is_period_dtype(arr_or_dtype)	检查数组类型或dtype是否为Period dtype。
api.types.is_signed_integer_dtype(arr_or_dtype)	检查提供的数组或dtype是否为带符号整数dtype。
api.types.is_string_dtype(arr_or_dtype)	检查提供的数组或dtype是否为字符串dtype。
api.types.is_timedelta64_dtype(arr_or_dtype)	检查数组类型或dtype是否属于timedelta64 dtype。
api.types.is_timedelta64_ns_dtype(arr_or_dtype)	检查提供的数组或dtype是否为timedelta64 [ns] dtype。
api.types.is_unsigned_integer_dtype(arr_or_dtype)	检查提供的数组或dtype是否为无符号整数dtype。
api.types.is_sparse(arr)	检查数组是否是pandas稀疏数组。

Iterable introspection

api.types.is_dict_like(obj)	检查对象是否像dict一样。
api.types.is_file_like(obj)	检查对象是否是类文件对象。
api.types.is_list_like(obj)	检查对象是否类似于列表。
api.types.is_named_tuple(obj)	检查对象是否是命名元组。
api.types.is_iterator(obj)	检查对象是否是迭代器。

Scalar introspection

api.types.is_bool	
api.types.is_categorical(arr)	检查类似数组是否是分类实例。
api.types.is_complex	
api.types.is_datetimetz(arr)	检查类似数组是否与日期时间数组一样，其dtype中包含时区组件。
api.types.is_float	
api.types.is_hashable(obj)	如果hash（obj）成功则返回True，否则返回False。
api.types.is_integer	
api.types.is_interval	
api.types.is_number(obj)	检查对象是否为数字。
api.types.is_period(arr)	检查类似数组是否是一个周期性索引。
api.types.is_re(obj)	检查对象是否是正则表达式模式实例。
api.types.is_re_compilable(obj)	检查对象是否可以编译为正则表达式模式实例。
api.types.is_scalar	如果给定值是标量，则返回True。

Extensions
这些主要用于寻求扩展pandas对象的图书馆作者。

api.extensions.register_dataframe_accessor(name)	在DataFrame对象上注册自定义访问器。
api.extensions.register_series_accessor(name)	在Series对象上注册自定义访问器。
api.extensions.register_index_accessor(name)	在Index对象上注册自定义访问器。
api.extensions.ExtensionDtype	自定义数据类型，与ExtensionArray配对。
api.extensions.ExtensionArray	自定义1-D数组类型的抽象基类。