Pandas手册汉化

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

输入/输出

Pickling

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

平面文件

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对象

剪贴板

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, …])：从中创建表模式data

HTML

read_html(io[, match, flavor, header, …])：阅读HTML表格到list的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_label()：返回Stata文件的数据标签

StataReader.value_labels()：返回一个dict，将每个变量名称与一个dict相关联，将每个值与其对

StataReader.variable_labels()：将变量标签作为dict返回，将每个变量名称与相应的标签相关联

一般功能

数据处理

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])：宽面板到长格式。

顶级缺失数据

isna(obj)：检测类似数组的对象的缺失值。

isnull(obj)：检测类似数组的对象的缺失值。

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

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

顶级转换

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

顶级处理时间

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])：根据输入索引推断最可能的频率。

顶级处理间隔

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

顶级评估

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

Series

构造函数

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

属性

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属性（如果有）

转换

Series.astype(dtype[, copy, errors])：将pandas对象转换为指定的dtypedtype。

Series.infer_objects()：尝试推断对象列的更好的dtypes。

Series.convert_objects([convert_dates, …])：（DEPRECATED）尝试推断对象列的更好dtype。

Series.copy([deep])：复制此对象的索引和数据。

Series.bool()：返回单个元素PandasObject的bool。

Series.to_period([freq, copy])：将Series从DatetimeIndex转换为具有所需频率的PeriodIndex（如果未传递，则从索引推断）

Series.to_timestamp([freq, how, copy])：在期间开始时转换为时间戳的datetimedex

Series.tolist()：返回值列表。

Series.get_values()：与值相同（但处理稀疏转换）; 是一种观点

索引, 迭代

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的横截面（行或列）。

For more information on .at, .iat, .loc, and .iloc, see the indexing documentation

二元运算符函数

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）

计算/ 描述性统计

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])：返回最大值和之间的差值

重新索引/ 选择/ 标签操作

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])：根据指定索引中的标签设置数据框的行或列。

缺少数据处理

Series.isna()：检测缺失值。

Series.notna()：检测现有（非缺失）值。

Series.dropna([axis, inplace])：返回删除了缺失值的新系列。

Series.fillna([value, method, axis, …])：使用指定的方法填充NA / NaN值

Series.interpolate([method, axis, limit, …])：根据不同的方法插值。

重塑, 排序

Series.argsort([axis, kind, order])：覆盖ndarray.argsort。

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])：Unstack，又名

Series.searchsorted(value[, side, sorter])：查找应插入元素以维护顺序的索引。

Series.ravel([order])：将展平的底层数据作为ndarray返回

Series.repeat(repeats, *args, **kwargs)：重复系列的元素。

Series.squeeze([axis])：挤压长度1维。

Series.view([dtype])：创建系列的新视图。

合并/ 加入

Series.append(to_append[, ignore_index, …])：连接两个或更多系列

Series.replace([to_replace, value, inplace, …])：替换给定的值to_replace与价值.

Series.update(other)：使用传递的Series中的非NA值修改系列

时间序列

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])：相当于移位而不复制数据。

类似日期的属性

Series.dt可用于以datetimelike的形式访问系列的值并返回多个属性。这些可以像访问Series.dt.<property>.

日期时间属性

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.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 属性

Series.dt.days：每个元素的天数。

Series.dt.seconds：每个元素的秒数（> = 0且小于1天）。

Series.dt.microseconds：每个元素的微秒数（> = 0且小于1秒）。

Series.dt.nanoseconds：每个元素的纳秒数（> = 0且小于1微秒）。

Series.dt.components：返回Timedeltas的组件（天，小时，分钟，秒，毫秒，微秒，纳秒）的数据帧。

Timedelta 方法

Series.dt.to_pytimedelta()：返回本机datetime.timedelta对象的数组.

Series.dt.total_seconds(*args, **kwargs)：返回每个元素的总持续时间，以秒为单位表示

字符串处理

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

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时拆分字符串，并返回包含分隔符之前的部分的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中的每个字符串，并返回一个虚拟/指示变量框。

绘图

Series.plot对于表单的特定绘图方法，它既是可调用方法又是命名空间属性Series.plot.<kind>.

Series.plot([kind, ax, figsize, ….])：系列绘图访问器和方法

Series.hist([by, ax, grid, xlabelsize, …])：使用matplotlib绘制输入序列的直方图

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)：饼形图

序列化/ IO / 转换

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

构造函数

DataFrame([data, index, columns, dtype, copy])：具有标记轴（行和列）的二维大小可变，可能异构的表格数据结构.

属性和基础数据

Axes

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.index：DataFrame的索引（行标签）。

DataFrame.columns：DataFrame的列标签。

转换

DataFrame.astype(dtype[, copy, errors])：将pandas对象转换为指定的dtypedtype。

DataFrame.convert_objects([convert_dates, …])：（DEPRECATED）尝试推断对象列的更好dtype。

DataFrame.infer_objects()：尝试推断对象列的更好的dtypes。

DataFrame.copy([deep])：复制此对象的索引和数据。

DataFrame.isna()：检测缺失值。

DataFrame.notna()：检测现有（非缺失）值。

DataFrame.bool()：返回单个元素PandasObject的bool。

索引, 迭代

DataFrame.head([n])：返回前n行。

DataFrame.at：访问行/列标签对的单个值。

DataFrame.iat：按整数位置访问行/列对的单个值。

DataFrame.loc：通过标签或布尔数组访问一组行和列。

DataFrame.iloc：纯粹基于整数位置的索引，用于按位置选择。

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])：使用布尔表达式查询帧的列。

For more information on .at, .iat, .loc, and .iloc, see the indexing documentation

二元运算符函数

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])：用于灵活比较方法的包装器

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, …])：提供指数加权函数

计算/ 描述性统计

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])：返回具有所请求轴上的不同观察数的系列。

重新索引/ 选择/ 标签操作

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。

缺少数据处理

DataFrame.dropna([axis, how, thresh, …])：删除缺失的值。

DataFrame.fillna([value, method, axis, …])：使用指定的方法填充NA / NaN值

DataFrame.replace([to_replace, value, …])：替换给定的值to_replace与价值。

DataFrame.interpolate([method, axis, limit, …])：根据不同的方法插值。

重塑, 排序, 转置

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])：返回第一个ñ通过有序的行列按降序排列。

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)：转置索引和列。

合并/ 加入

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值进行就地修改。

时间序列

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本地化为目标时区。

绘图

DataFrame.plot对于表单的特定绘图方法，它既是可调用方法又是命名空间属性DataFrame.plot.<kind>.

DataFrame.plot([x, y, kind, ax, ….])：DataFrame绘制访问器和方法

DataFrame.boxplot([column, by, ax, …])：从DataFrame列创建一个箱形图.

DataFrame.hist([column, by, grid, …])：制作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])：创建具有不同标记点大小和颜色的散点图。

序列化/ IO / 转换

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矩阵返回.

面板

Attributes and underlying data

Axes

项目：轴0; 每个项目对应一个包含在其中的DataFrame

major_axis：轴1; 每个DataFrame的索引（行）

minor_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）返回此对象中唯一ftypes的计数

转换

Panel.astype(dtype[, copy, errors])：将pandas对象转换为指定的dtype dtype。

Panel.copy([deep])：复制此对象的索引和数据。

Panel.isna()：检测缺失值。

Panel.notna()：检测现有（非缺失）值。

索引, 迭代, 切片

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)：沿短轴返回面板切片

For more information on .at, .iat, .loc, and .iloc, see the indexing documentation.

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对象

计算/ 描述属性

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, …])：在请求的轴上返回无偏差异。

重新索引/ 选择/ 标签操作

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。

缺少数据处理

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

重塑, 排序, 转置

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符合选定的轴对。

合并/ 加入

Panel.join(other[, how, lsuffix, rsuffix])：在主轴和次轴列上与其他面板连接项目

Panel.update(other[, join, overwrite, …])：使用来自传递的Panel的非NA值或可强制化为Panel的对象来修改面板。

时间序列相关

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本地化为目标时区。

序列化/ IO / 转换

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])：将对象复制到系统剪贴板。

索引

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

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

属性

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]）：内存使用值

修改和计算

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)：更灵活，更快速的检查，is但通过视图工作

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])：版本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, …])：返回包含唯一值计数的对象。

缺少值

Index.fillna([value, downcast])：使用指定值填充NA / NaN值

Index.dropna([how])：返回没有NA / NaN值的索引

Index.isna()：检测缺失值。

Index.notna()：检测现有（非缺失）值

转换

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.argsort(*args, **kwargs)：返回将对索引进行排序的整数指标

Index.searchsorted(value[, side, sorter])：查找应插入元素以维护顺序的索引

Index.sort_values([return_indexer, ascending])：返回索引的排序副本

特定时间的操作

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

组合/ 加入/ 设置操作

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对象的对称差异

选择

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

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：用于pandas对象的多级或分层索引对象

IndexSlice：创建一个对象以更轻松地执行多索引切片

MultiIndex 构造函数

MultiIndex.from_arrays(arrays[, sortorder, …])：将数组转换为MultiIndex

MultiIndex.from_tuples(tuples[, sortorder, …])：将元组列表转换为MultiIndex

MultiIndex.from_product(iterables[, …])：从多个迭代的笛卡尔积中创建一个MultiIndex

MultiIndex 属性

MultiIndex.names：MultiIndex中的级别名称

MultiIndex.levels：

MultiIndex.labels：

MultiIndex.nlevels：此MultiIndex中的整数级别。

MultiIndex.levshape：每个级别长度的元组。

MultiIndex 组件

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])：返回索引中的唯一值。

MultiIndex 选择

MultiIndex.get_loc(key[, method])：获取标签或标签元组的位置作为整数，切片或布尔掩码。

MultiIndex.get_indexer(target[, method, …])：给定当前索引计算新索引的索引器和掩码。

MultiIndex.get_level_values(level)：返回请求级别的标签值向量，等于索引的长度

DatetimeIndex

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

选择时间/日期组件

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生成的频率猜测的字符串

选择

DatetimeIndex.indexer_at_time（time[，asof]）：返回特定时刻的索引值的索引位置（例如，

DatetimeIndex.indexer_between_time（... [，...]）：返回值的特定时间之间的值的索引位置（例如，9：00-9：30AM）。

特定时间的操作

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的日期名称。

转换

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对象

ConversionComponents

TimedeltaIndex.days：每个元素的天数。

TimedeltaIndex.seconds：每个元素的秒数（> = 0且小于1天）。

TimedeltaIndex.microseconds：每个元素的微秒数（> = 0且小于1秒）。

TimedeltaIndex.nanoseconds：每个元素的纳秒数（> = 0且小于1微秒）。

TimedeltaIndex.components：返回Timedeltas的组件（天，小时，分钟，秒，毫秒，微秒，纳秒）的数据帧。

TimedeltaIndex.inferred_freq：尝试返回表示由infer_freq生成的频率猜测的字符串。

转换

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持有序数值，表示特定的时间段，如特定的年，季度，月等

属性

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本地化为给定时区（using pytz/dateutil），或从tz-aware DatetimeIndex中删除时区

标量

Period

Period：代表一段时间

属性

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.second：获取期间的第二个组成部分。

Period.start_time：获取期间开始的时间戳。

Period.week：获取给定期间的一年中的一周。

Period.weekday：

Period.weekofyear：

Period.year：

方法

Period.asfreq：将周期转换为所需频率，在间隔的开始或结束时

Period.now：

Period.strftime：返回的字符串表示形式Period，具体取决于所选的fmt。

Period.to_timestamp：将Period的Timestamp表示返回到Period的指定末尾（how）的目标频率

时间戳

Timestamp：Pandas 替换 for datetime.datetime

方法

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.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.closed：是否在左侧，右侧，两侧或两者都关闭间隔

Interval.closed_left：检查左侧是否关闭间隔。

Interval.closed_right：检查右侧是否关闭间隔。

Interval.left：左边界限

Interval.length：返回Interval的长度

Interval.mid：返回间隔的中点

Interval.open_left：检查左侧是否打开间隔。

Interval.open_right：检查右侧是否打开间隔。

Interval.right：右边界限

Timedelta

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

属性

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

方法

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精度计）

频率

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()，等.

标准移动窗口函数

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的窗口总和。

标准扩展窗口函数

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])：扩大分位数。

指数加权移动窗口函数

EWM.mean(*args, **kwargs)：指数加权移动平均线

EWM.std([bias])：指数加权移动stddev

EWM.var([bias])：指数加权移动方差

EWM.corr([other, pairwise])：指数加权样本相关

EWM.cov([other, pairwise, bias])：指数加权样本协方差

GroupBy

GroupBy objects are returned by groupby calls: pandas.DataFrame.groupby(), pandas.Series.groupby(), etc.

索引, 迭代

GroupBy.__iter__()：Groupby迭代器

GroupBy.groups：dict {组名 - >组标签}

GroupBy.indices：dict {组名 - >组索引}

GroupBy.get_group(name[, obj])：从提供名称的组构造NDFrame

Grouper([key, level, freq, axis, sort])：Grouper允许用户为目标对象指定groupby指令

功能应用

GroupBy.apply(func, *args, **kwargs)：func 分组应用功能并将结果组合在一起.

GroupBy.aggregate(func, *args, **kwargs)：

GroupBy.transform(func, *args, **kwargs)：

GroupBy.pipe(func, *args, **kwargs)：将func带有参数的函数应用于此GroupBy对象并返回函数的结果.

计算/ 描述性统计

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数据制作箱形图.

重新采样

重新采样对象由resample调用返回: pandas.DataFrame.resample(), pandas.Series.resample().

索引, 迭代

Resampler.__iter__()：Groupby迭代器

Resampler.groups：dict {组名 - >组标签}

Resampler.indices：dict {组名 - >组索引}

Resampler.get_group(name[, obj])：从提供名称的组构造NDFrame

功能应用

Resampler.apply(arg, *args, **kwargs)：使用指定轴上的一个或多个操作进行聚合。

Resampler.aggregate(arg, *args, **kwargs)：使用指定轴上的一个或多个操作进行聚合。

Resampler.transform(arg, *args, **kwargs)：调用函数在每个组上生成类似索引的Series，并返回带有转换值的Series

Resampler.pipe(func, *args, **kwargs)：将func带有参数的函数应用于此Resampler对象并返回函数的结果。

上采样

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, …])：根据不同的方法插值。

计算/ 描述性统计

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

Styler objects are returned by pandas.DataFrame.style.

Styler 构造函数

Styler(data[, precision, table_styles, …])：根据HTML和CSS的数据帮助设置DataFrame或Series的样式.

Styler.from_custom_template(searchpath, name)：用于创建Styler具有自定义模板和Jinja环境的子类的工厂函数.

Styler 属性

`Styler.env`
`Styler.template`
`Styler.loader`

风格应用

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()：“重置”样式器，删除任何以前应用的样式。

内置样式

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])：将背景颜色设置color为每列中的值。

样式导出和导入

Styler.render(**kwargs)：将构建的样式呈现为HTML

Styler.export()：导出要应用于当前Styler的样式。

Styler.use(styles)：在当前Styler上设置样式，可能使用样式Styler.export。

Styler.to_excel(excel_writer[, sheet_name, …])：将Styler写入Excel工作表

绘图

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, …])：绘制散点图矩阵。

一般实用功能

使用选项

describe_option(pat[, _print_desc])：打印一个或多个已注册选项的说明。

reset_option(pat)：将一个或多个选项重置为其默认值。

get_option(pat)：检索指定选项的值。

set_option(pat, value)：设置指定选项的值。

option_context(*args)：上下文管理器临时设置with语句上下文中的选项。

测试功能

testing.assert_frame_equal(left, right[, …])：检查左右DataFrame是否相等。

testing.assert_series_equal(left, right[, …])：检查左右系列是否相等。

testing.assert_index_equal(left, right[, …])：检查左右索引是否相等。

例外 and 警告

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函数时引发异常，但该对象不支持该函数，例如

数据类型相关功能

api.types.union_categoricals(to_union[, …])：结合列表类似类别，联合类别。

api.types.infer_dtype：有效地推断传递的val或类似列表的数组的类型。

api.types.pandas_dtype(dtype)：将输入转换为仅pandas的dtype对象或numpy dtype对象。

Dtype内省

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稀疏数组。

可迭代的内省

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)：检查对象是否是迭代器。

标量内省

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。

扩展

这些主要用于寻求扩展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数组类型的抽象基类。

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

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行