Series#

构造函数#

Series([data, index, dtype, name, copy])

带轴标签的一维 ndarray（包括时间序列）。

属性#

轴

Series.index

Series 的索引（轴标签）。

Series.array

支持此 Series 或 Index 的底层数据的 ExtensionArray。

Series.values

根据 dtype 返回 Series 作为 ndarray 或 ndarray-like。

Series.dtype

返回底层数据的 dtype 对象。

Series.info([verbose, buf, max_cols, ...])

打印 Series 的简洁摘要。

Series.shape

返回底层数据的 shape 元组。

Series.nbytes

返回底层数据的字节数。

Series.ndim

底层数据的维度数，定义为 1。

Series.size

返回底层数据的元素数量。

Series.T

返回转置，按定义是自身。

Series.memory_usage([index, deep])

返回 Series 的内存使用情况。

Series.hasnans

如果存在任何 NaN，则返回 True。

Series.empty

指示 Index 是否为空。

Series.dtypes

返回底层数据的 dtype 对象。

Series.name

返回 Series 的名称。

Series.flags

获取与此 pandas 对象相关的属性。

Series.set_flags(*[, copy, ...])

返回一个带有更新标志的新对象。

转换#

Series.astype(dtype[, copy, errors])

将 pandas 对象强制转换为指定的数据类型 dtype。

Series.convert_dtypes([infer_objects, ...])

将列从 numpy 数据类型转换为支持 pd.NA 的最佳数据类型。

Series.infer_objects([copy])

尝试为 object 列推断更合适的数据类型。

Series.copy([deep])

复制此对象的索引和数据。

Series.to_numpy([dtype, copy, na_value])

Series 或 Index 中值的 NumPy ndarray 表示形式。

Series.to_period([freq, copy])

将 Series 从 DatetimeIndex 转换为 PeriodIndex。

Series.to_timestamp([freq, how, copy])

转换为 DatetimeIndex 的时间戳，位于时间段的开始。

Series.to_list()

返回值的列表。

Series.__array__([dtype, copy])

将值作为 NumPy 数组返回。

索引、迭代#

Series.get(key[, default])

获取对象中给定键（例如 DataFrame 列）的项。

Series.at

通过行/列标签对访问单个值。

Series.iat

通过整数位置通过行/列对访问单个值。

Series.loc

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

Series.iloc

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

Series.__iter__()

返回值的迭代器。

Series.items()

延迟迭代 (index, value) 元组。

Series.keys()

返回索引的别名。

Series.pop(item)

返回元素并从 series 中删除。

Series.item()

将底层数据的第一个元素作为 Python 标量返回。

Series.xs(key[, axis, level, drop_level])

从 Series/DataFrame 返回横截面。

有关 .at, .iat, .loc, 和 .iloc 的更多信息，请参阅 索引文档。

二元运算符函数#

Series.add(other[, level, fill_value, axis])

返回 Series 与 other 的相加结果，逐元素进行 (二元运算符 add)。

Series.sub(other[, level, fill_value, axis])

返回 Series 与 other 的减法，逐元素（二元运算符 sub）。

Series.mul(other[, level, fill_value, axis])

返回 Series 与 other 的乘法，逐元素（二元运算符 mul）。

Series.div(other[, level, fill_value, axis])

返回 Series 与 other 的浮点数除法，逐元素进行（二元运算符 truediv）。

Series.truediv(other[, level, fill_value, axis])

返回 Series 与 other 的浮点数除法，逐元素进行（二元运算符 truediv）。

Series.floordiv(other[, level, fill_value, axis])

返回 Series 与 other 的整数除法，逐元素（二元运算符 floordiv）。

Series.mod(other[, level, fill_value, axis])

返回 Series 与 other 的模运算，逐元素（二元运算符 mod）。

Series.pow(other[, level, fill_value, axis])

返回 Series 与 other 的指数幂，逐元素（二元运算符 pow）。

Series.radd(other[, level, fill_value, axis])

返回 Series 与 other 的加法，逐元素（二元运算符 radd）。

Series.rsub(other[, level, fill_value, axis])

返回 Series 与 other 的元素级减法 (二进制操作符 rsub )。

Series.rmul(other[, level, fill_value, axis])

返回 Series 与 other 的乘法，逐元素（二元运算符 rmul）。

Series.rdiv(other[, level, fill_value, axis])

返回 Series 与 other 的浮点除法，逐元素（二元运算符 rtruediv）。

Series.rtruediv(other[, level, fill_value, axis])

返回 Series 与 other 的浮点除法，逐元素（二元运算符 rtruediv）。

Series.rfloordiv(other[, level, fill_value, ...])

返回 Series 与 other 的整数除法，逐元素（二元运算符 rfloordiv）。

Series.rmod(other[, level, fill_value, axis])

返回 Series 和 other 的模，逐元素进行计算（二元运算符 rmod）。

Series.rpow(other[, level, fill_value, axis])

返回 Series 与 other 的指数幂，逐元素（二元运算符 rpow）。

Series.combine(other, func[, fill_value])

根据 func 将 Series 与 Series 或标量组合。

Series.combine_first(other)

使用 'other' 中相同位置的值更新空值元素。

Series.round([decimals])

将 Series 中的每个值四舍五入到指定的小数位数。

Series.lt(other[, level, fill_value, axis])

返回 Series 与 other 的小于比较，逐元素（二元运算符 lt）。

Series.gt(other[, level, fill_value, axis])

返回 Series 与 other 的大于比较，逐元素（二元运算符 gt）。

Series.le(other[, level, fill_value, axis])

返回 series 和 other 的小于或等于（元素级）（二进制运算符 le）。

Series.ge(other[, level, fill_value, axis])

返回 Series 与 other 的大于或等于比较，逐元素（二元运算符 ge）。

Series.ne(other[, level, fill_value, axis])

返回 Series 与 other 的不等于比较，逐元素（二元运算符 ne）。

Series.eq(other[, level, fill_value, axis])

返回 Series 与 other 的等于比较，逐元素（二元运算符 eq）。

Series.product(*[, axis, skipna, ...])

返回所请求轴上值的乘积。

Series.dot(other)

计算 Series 与 other 列之间的点积。

函数应用、GroupBy 和窗口#

Series.apply(func[, args, by_row])

对 Series 的值调用函数。

Series.agg([func, axis])

沿指定轴对一个或多个操作进行聚合。

Series.aggregate([func, axis])

沿指定轴对一个或多个操作进行聚合。

Series.transform(func[, axis])

调用 func 作用于 self，生成一个与 self 具有相同轴形状的 Series。

Series.map([func, na_action, engine])

根据输入映射或函数映射 Series 的值。

Series.groupby([by, level, as_index, sort, ...])

使用映射器或列Series对Series进行分组。

Series.rolling(window[, min_periods, ...])

提供滚动窗口计算。

Series.expanding([min_periods, method])

提供扩展窗口计算。

Series.ewm([com, span, halflife, alpha, ...])

提供指数加权 (EW) 计算。

Series.pipe(func, *args, **kwargs)

应用期望 Series 或 DataFrame 的链式函数。

计算/描述性统计#

Series.abs()

返回一个 Series/DataFrame，其中包含每个元素的绝对数值。

Series.all(*[, axis, bool_only, skipna])

返回所有元素是否为 True，可能沿轴。

Series.any(*[, axis, bool_only, skipna])

返回任何元素是否为 True，可能沿轴。

Series.autocorr([lag])

计算滞后 N 的自相关。

Series.between(left, right[, inclusive])

返回一个布尔 Series，等价于 left <= series <= right。

Series.clip([lower, upper, axis, inplace])

在输入阈值处修剪值。

Series.corr(other[, method, min_periods])

计算与 other Series 的相关性，排除缺失值。

Series.count()

返回 Series 中非 NA/null 观测值的数量。

Series.cov(other[, min_periods, ddof])

计算与 Series 的协方差，排除缺失值。

Series.cummax([axis, skipna])

返回 Series 上的累积最大值。

Series.cummin([axis, skipna])

返回 Series 上的累积最小值。

Series.cumprod([axis, skipna])

返回 Series 上的累积乘积。

Series.cumsum([axis, skipna])

返回 Series 的累积和。

Series.describe([percentiles, include, exclude])

生成描述性统计信息。

Series.diff([periods])

Series 元素的离散一阶差分。

Series.factorize([sort, use_na_sentinel])

将对象编码为枚举类型或分类变量。

Series.kurt(*[, axis, skipna, numeric_only])

返回所请求轴上的无偏峰度。

Series.max(*[, axis, skipna, numeric_only])

返回所请求轴上值的最大值。

Series.mean(*[, axis, skipna, numeric_only])

返回所请求轴上值的平均值。

Series.median(*[, axis, skipna, numeric_only])

返回所请求轴上值的中间值。

Series.min(*[, axis, skipna, numeric_only])

返回所请求轴上值的最小值。

Series.mode([dropna])

返回 Series 的众数。

Series.nlargest([n, keep])

返回最大的 n 个元素。

Series.nsmallest([n, keep])

返回最小的 n 个元素。

Series.pct_change([periods, fill_method, freq])

当前元素与先前元素之间的分数变化。

Series.prod(*[, axis, skipna, numeric_only, ...])

返回所请求轴上值的乘积。

Series.quantile([q, interpolation])

返回给定分位数的值。

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

沿轴计算数值数据排名（1 到 n）。

Series.sem(*[, axis, skipna, ddof, numeric_only])

返回请求轴上未偏倚的均值标准误差。

Series.skew(*[, axis, skipna, numeric_only])

返回请求轴上未偏倚的偏度。

Series.std(*[, axis, skipna, ddof, numeric_only])

返回样本标准差。

Series.sum(*[, axis, skipna, numeric_only, ...])

返回请求轴上的值之和。

Series.var(*[, axis, skipna, ddof, numeric_only])

返回请求轴上的未偏倚方差。

Series.kurtosis(*[, axis, skipna, numeric_only])

返回所请求轴上的无偏峰度。

Series.unique()

返回 Series 对象的唯一值。

Series.nunique([dropna])

返回对象中唯一元素的数量。

Series.is_unique

如果对象中的值是唯一的，则返回 True。

Series.is_monotonic_increasing

如果对象中的值是单调递增的，则返回 True。

Series.is_monotonic_decreasing

如果对象中的值单调递减，则返回 True。

Series.value_counts([normalize, sort, ...])

返回一个包含唯一值计数的 Series。

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

Series.align(other[, join, axis, level, ...])

使用指定的连接方法将两个对象按其轴对齐。

Series.case_when(caselist)

替换条件为 True 的值。

Series.drop([labels, axis, index, columns, ...])

返回删除指定索引标签的 Series。

Series.droplevel(level[, axis])

返回删除指定索引/列级别的 Series/DataFrame。

Series.drop_duplicates(*[, keep, inplace, ...])

返回删除重复值的 Series。

Series.duplicated([keep])

指示 Series 中的重复值。

Series.equals(other)

测试两个对象是否包含相同元素。

Series.head([n])

返回前 n 行。

Series.idxmax([axis, skipna])

返回最大值的行标签。

Series.idxmin([axis, skipna])

返回最小值行标签。

Series.isin(values)

检查 Series 中的元素是否存在于 values 中。

Series.reindex([index, axis, method, copy, ...])

使用可选的填充逻辑来统一 Series 的新索引。

Series.reindex_like(other[, method, copy, ...])

返回一个具有与另一个对象匹配的索引的对象。

Series.rename([index, axis, copy, inplace, ...])

更改 Series 索引标签或名称。

Series.rename_axis([mapper, index, axis, ...])

设置索引的轴名称。

Series.reset_index([level, drop, name, ...])

生成一个新的 DataFrame 或 Series，其中索引已重置。

Series.sample([n, frac, replace, weights, ...])

从对象的轴返回随机样本项。

Series.set_axis(labels, *[, axis, copy])

(已弃用) 将所需的索引分配给指定的轴。

Series.take(indices[, axis])

沿轴返回给定位置索引中的元素。

Series.tail([n])

返回最后 n 行。

Series.truncate([before, after, axis, copy])

截断 Series 或 DataFrame 在某个索引值之前和之后的部分。

Series.where(cond[, other, inplace, axis, level])

替换条件为 False 的值。

Series.mask(cond[, other, inplace, axis, level])

替换条件为 True 的值。

Series.add_prefix(prefix[, axis])

为标签添加前缀字符串prefix。

Series.add_suffix(suffix[, axis])

为标签添加后缀字符串suffix。

Series.filter([items, like, regex, axis])

根据指定的索引标签子集化 DataFrame 或 Series。

缺失数据处理#

Series.bfill(*[, axis, inplace, limit, ...])

使用下一个有效观测值填充 NA/NaN 值以填补空白。

Series.dropna(*[, axis, inplace, how, ...])

返回删除缺失值的新 Series。

Series.ffill(*[, axis, inplace, limit, ...])

通过传播最后一个有效观测值来填充 NA/NaN 值。

Series.fillna(value, *[, axis, inplace, limit])

用value填充 NA/NaN 值。

Series.interpolate([method, axis, limit, ...])

使用插值方法填充 NaN 值。

Series.isna()

检测缺失值。

Series.isnull()

Series.isnull 是 Series.isna 的别名。

Series.notna()

检测存在的（非缺失）值。

Series.notnull()

Series.notnull 是 Series.notna 的别名。

Series.replace([to_replace, value, inplace, ...])

用value替换to_replace中给定的值。

重塑、排序#

Series.argsort([axis, kind, order, stable])

返回对 Series 值进行排序的整数索引。

Series.argmin([axis, skipna])

返回 Series 中最小值的整数位置。

Series.argmax([axis, skipna])

返回 Series 中最大值的整数位置。

Series.reorder_levels(order)

使用输入顺序重新排列索引级别。

Series.sort_values(*[, axis, ascending, ...])

按值排序。

Series.sort_index(*[, axis, level, ...])

按索引标签排序 Series。

Series.swaplevel([i, j, copy])

在 MultiIndex 中交换级别 i 和 j。

Series.unstack([level, fill_value, sort])

将具有 MultiIndex 的 Series 展平（也称为透视）以生成 DataFrame。

Series.explode([ignore_index])

将列表状元素的每个元素转换为一行。

Series.searchsorted(value[, side, sorter])

查找元素应插入以保持顺序的索引。

Series.repeat(repeats[, axis])

重复 Series 的元素。

Series.squeeze([axis])

将一维轴对象压缩成标量。

组合/比较/连接/合并#

Series.compare(other[, align_axis, ...])

与另一个 Series 比较并显示差异。

Series.update(other)

使用传入 Series 中的值就地修改 Series。

访问器#

pandas 在各种访问器下提供了特定于数据类型的显式方法。这些是 Series 中的独立命名空间，仅适用于特定的数据类型。

Series.str

别名 StringMethods

Series.cat

别名 CategoricalAccessor

Series.dt

别名 CombinedDatetimelikeProperties

Series.sparse

别名 SparseAccessor

DataFrame.sparse

别名 SparseFrameAccessor

Index.str

别名 StringMethods

数据类型

访问器

日期时间、时间差、周期

dt

字符串

str

Categorical

cat

Sparse

sparse

日期时间类属性#

Series.dt 可用于将 Series 的值作为日期时间类来访问，并返回几个属性。这些属性可以像 Series.dt.<property> 一样访问。

日期时间属性#

Series.dt.date

返回 Python datetime.date 对象的 numpy 数组。

Series.dt.time

返回 datetime.time 对象的 numpy 数组。

Series.dt.timetz

返回包含时区的 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.dayofweek

星期几，周一=0，周日=6。

Series.dt.day_of_week

星期几，周一=0，周日=6。

Series.dt.weekday

星期几，周一=0，周日=6。

Series.dt.dayofyear

一年中的序数日。

Series.dt.day_of_year

一年中的序数日。

Series.dt.days_in_month

月份的天数。

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

尝试返回一个表示由 infer_freq 生成的频率的字符串。

Series.dt.unit

日期时间数据的精度单位。

日期时间方法#

Series.dt.isocalendar()

根据 ISO 8601 标准计算年、周和日。

Series.dt.to_period([freq])

在特定频率下转换为 PeriodArray/PeriodIndex。

Series.dt.to_pydatetime()

将数据作为 datetime.datetime 对象的 Series 返回。

Series.dt.tz_localize(tz[, ambiguous, ...])

将时区感知的 Datetime 数组/索引本地化为时区感知的 Datetime 数组/索引。

Series.dt.tz_convert(tz)

将时区感知的 Datetime 数组/索引从一个时区转换为另一个时区。

Series.dt.normalize()

将时间转换为午夜。

Series.dt.strftime(date_format)

使用指定的 date_format 转换为 Index。

Series.dt.round(freq[, ambiguous, nonexistent])

对数据执行四舍五入操作到指定的 freq。

Series.dt.floor(freq[, ambiguous, nonexistent])

对数据执行向下取整操作到指定的 freq。

Series.dt.ceil(freq[, ambiguous, nonexistent])

对数据执行向上取整操作到指定的 freq。

Series.dt.month_name([locale])

返回指定区域设置的月份名称。

Series.dt.day_name([locale])

返回指定区域设置的星期名称。

Series.dt.as_unit(unit[, round_ok])

转换为具有给定单元分辨率的 dtype。

周期属性#

Series.dt.qyear

根据其起始季度，Period 所属的财政年度。

Series.dt.start_time

获取 Period 开始时间戳。

Series.dt.end_time

获取 Period 结束时间戳。

时间差属性#

Series.dt.days

每个元素的日数。

Series.dt.seconds

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

Series.dt.microseconds

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

Series.dt.nanoseconds

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

Series.dt.components

返回包含时间差组件的 DataFrame。

Series.dt.unit

日期时间数据的精度单位。

时间差方法#

Series.dt.to_pytimedelta()

返回本机 datetime.timedelta 对象的数组。

Series.dt.total_seconds()

以秒为单位返回每个元素的总持续时间。

Series.dt.as_unit(unit[, round_ok])

转换为具有给定单元分辨率的 dtype。

字符串处理#

Series.str 可用于将 Series 的值作为字符串来访问，并对其应用多个方法。这些方法可以像 Series.str.<function/property> 一样访问。

Series.str.capitalize()

将 Series/Index 中的字符串转换为首字母大写。

Series.str.casefold()

将 Series/Index 中的字符串转换为折叠大小写。

Series.str.cat([others, sep, na_rep, join])

使用指定的分隔符连接 Series/Index 中的字符串。

Series.str.center(width[, fillchar])

填充 Series/Index 中的字符串的左侧和右侧。

Series.str.contains(pat[, case, flags, na, ...])

测试 Series 或 Index 的字符串是否包含模式或正则表达式。

Series.str.count(pat[, flags])

计算 Series/Index 中每个字符串中模式的出现次数。

Series.str.decode(encoding[, errors, dtype])

使用指定的编码解码 Series/Index 中的字符字符串。

Series.str.encode(encoding[, errors])

使用指定的编码对 Series/Index 中的字符字符串进行编码。

Series.str.endswith(pat[, na])

测试每个字符串元素的结尾是否与模式匹配。

Series.str.extract(pat[, flags, expand])

将正则表达式 pat 中的捕获组提取为 DataFrame 中的列。

Series.str.extractall(pat[, flags])

将正则表达式 pat 中的捕获组提取为 DataFrame 中的列。

Series.str.find(sub[, start, end])

返回 Series/Index 中每个字符串中的最低索引。

Series.str.findall(pat[, flags])

在 Series/Index 中查找模式或正则表达式的所有出现。

Series.str.fullmatch(pat[, case, flags, na])

确定每个字符串是否完全匹配正则表达式。

Series.str.get(i)

在指定位置或使用指定键提取每个组件的元素。

Series.str.index(sub[, start, end])

返回 Series/Index 中每个字符串中的最低索引。

Series.str.isascii()

检查每个字符串中的所有字符是否都是 ascii。

Series.str.join(sep)

使用传入的分隔符连接 Series/Index 中包含的列表。

Series.str.len()

计算 Series/Index 中每个元素的长度。

Series.str.ljust(width[, fillchar])

填充 Series/Index 中的字符串的右侧。

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/Index 中的字符串填充到指定宽度。

Series.str.partition([sep, expand])

在第一次出现 sep 时分割字符串。

Series.str.removeprefix(prefix)

从对象 Series 中删除前缀。

Series.str.removesuffix(suffix)

从对象 Series 中删除后缀。

Series.str.repeat(repeats)

重复 Series 或 Index 中的每个字符串。

Series.str.replace(pat[, repl, n, case, ...])

替换 Series/Index 中模式/正则表达式的每次出现。

Series.str.rfind(sub[, start, end])

返回 Series/Index 中每个字符串中的最高索引。

Series.str.rindex(sub[, start, end])

返回 Series/Index 中每个字符串中的最高索引。

Series.str.rjust(width[, fillchar])

填充 Series/Index 中的字符串的左侧。

Series.str.rpartition([sep, expand])

在最后一次出现 sep 时分割字符串。

Series.str.rstrip([to_strip])

删除尾随字符。

Series.str.slice([start, stop, step])

从 Series 或 Index 的每个元素中切片子字符串。

Series.str.slice_replace([start, stop, repl])

用另一个值替换字符串的某个位置切片。

Series.str.split([pat, n, expand, regex])

在给定分隔符/定界符周围分割字符串。

Series.str.rsplit([pat, n, expand])

在给定分隔符/定界符周围分割字符串。

Series.str.startswith(pat[, na])

测试每个字符串元素的开头是否与模式匹配。

Series.str.strip([to_strip])

删除前导和尾随字符。

Series.str.swapcase()

将 Series/Index 中的字符串转换为交换大小写。

Series.str.title()

将 Series/Index 中的字符串转换为标题大小写。

Series.str.translate(table)

通过给定的映射表映射字符串中的所有字符。

Series.str.upper()

将 Series/Index 中的字符串转换为大写。

Series.str.wrap(width[, expand_tabs, ...])

在指定的行宽度处包装 Series/Index 中的字符串。

Series.str.zfill(width)

通过在 Series/Index 中的字符串前面添加 '0' 字符来填充。

Series.str.isalnum()

检查每个字符串中的所有字符是否都是字母数字。

Series.str.isalpha()

检查每个字符串中的所有字符是否都是字母。

Series.str.isdigit()

检查每个字符串中的所有字符是否都是数字。

Series.str.isspace()

检查每个字符串中的所有字符是否都是空白符。

Series.str.islower()

检查每个字符串中的所有字符是否都是小写。

Series.str.isupper()

检查每个字符串中的所有字符是否都是大写。

Series.str.istitle()

检查每个字符串中的所有字符是否都是标题大小写。

Series.str.isnumeric()

检查每个字符串中的所有字符是否都是数字。

Series.str.isdecimal()

检查每个字符串中的所有字符是否都是十进制数。

Series.str.get_dummies([sep, dtype])

为 Series 返回虚拟/指示变量的 DataFrame。

分类访问器#

特定于 Categorical-dtype 的方法和属性可在 Series.cat 访问器下获得。

Series.cat.categories

此分类数据的类别。

Series.cat.ordered

类别是否具有排序关系。

Series.cat.codes

返回代码 Series 和索引。

Series.cat.rename_categories(new_categories)

重命名类别。

Series.cat.reorder_categories(new_categories)

按 new_categories 中指定的顺序重新排列类别。

Series.cat.add_categories(new_categories)

添加新类别。

Series.cat.remove_categories(removals)

删除指定的类别。

Series.cat.remove_unused_categories()

删除未使用的类别。

Series.cat.set_categories(new_categories[, ...])

将类别设置为指定的新类别。

Series.cat.as_ordered()

将 Categorical 设置为有序。

Series.cat.as_unordered()

将 Categorical 设置为无序。

稀疏访问器#

特定于 Sparse-dtype 的方法和属性可在 Series.sparse 访问器下获得。

Series.sparse.npoints

非 fill_value 点的数量。

Series.sparse.density

非 fill_value 点的百分比，以小数表示。

Series.sparse.fill_value

data 中等于 fill_value 的元素不被存储。

Series.sparse.sp_values

包含非 fill_value 值的 ndarray。

Series.sparse.from_coo(A[, dense_index])

从 scipy.sparse.coo_matrix 创建一个具有稀疏值的 Series。

Series.sparse.to_coo([row_levels, ...])

从具有 MultiIndex 的 Series 创建 scipy.sparse.coo_matrix。

列表访问器#

Arrow list-dtype 特定方法和属性可在 Series.list 访问器下获得。

Series.list.flatten()

展平列表值。

Series.list.len()

返回 Series 中每个列表的长度。

Series.list.__getitem__(key)

索引或切片 Series 中的列表。

结构体访问器#

Arrow struct-dtype 特定方法和属性可在 Series.struct 访问器下获得。

Series.struct.dtypes

返回结构体每个子字段的 dtype 对象。

Series.struct.field(name_or_index)

将结构体的子字段提取为 Series。

Series.struct.explode()

将结构体的所有子字段提取为 DataFrame。

标志#

标志是指 pandas 对象的属性。数据集的属性（如记录日期、访问 URL 等）应存储在 Series.attrs 中。

Flags(obj, *, allows_duplicate_labels)

适用于 pandas 对象的标志。

元数据#

Series.attrs 是一个用于存储此 Series 的全局元数据的字典。

警告

Series.attrs 被认为是实验性的，可能会在没有警告的情况下更改。

Series.attrs

此数据集的全局属性字典。

绘图#

Series.plot 既是一个可调用的方法，也是一个命名空间属性，用于形式为 Series.plot.<kind> 的特定绘图方法。

Series.plot([kind, ax, figsize, ....])

Series 绘图访问器和方法

Series.plot.area([x, y, stacked])

绘制堆叠面积图。

Series.plot.bar([x, y, color])

垂直条形图。

Series.plot.barh([x, y, color])

绘制水平条形图。

Series.plot.box([by])

绘制 DataFrame 列的箱线图。

Series.plot.density([bw_method, ind, weights])

使用高斯核生成核密度估计图。

Series.plot.hist([by, bins])

绘制 DataFrame 列的直方图。

Series.plot.kde([bw_method, ind, weights])

使用高斯核生成核密度估计图。

Series.plot.line([x, y, color])

将 Series 或 DataFrame 绘制为折线图。

Series.plot.pie([y])

生成饼图。

Series.hist([by, ax, grid, xlabelsize, ...])

使用matplotlib绘制输入 Series 的直方图。

序列化/IO/转换#

Series.from_arrow(data)

从类数组 Arrow 对象构建 Series。

Series.to_pickle(path, *[, compression, ...])

将对象 pickle（序列化）到文件。

Series.to_csv([path_or_buf, sep, na_rep, ...])

将对象写入逗号分隔值 (csv) 文件。

Series.to_dict(*[, into])

将 Series 转换为 {标签 -> 值} 字典或类似字典的对象。

Series.to_excel(excel_writer, *[, ...])

将对象写入 Excel 工作表。

Series.to_frame([name])

将 Series 转换为 DataFrame。

Series.to_xarray()

从 pandas 对象返回一个 xarray 对象。

Series.to_hdf(path_or_buf, *, key[, mode, ...])

使用 HDFStore 将包含的数据写入 HDF5 文件。

Series.to_sql(name, con, *[, schema, ...])

将存储在 DataFrame 中的记录写入 SQL 数据库。

Series.to_json([path_or_buf, orient, ...])

将对象转换为 JSON 字符串。

Series.to_string([buf, na_rep, ...])

渲染 Series 的字符串表示。

Series.to_clipboard(*[, excel, sep])

将对象复制到系统剪贴板。

Series.to_latex([buf, columns, header, ...])

将对象渲染为 LaTeX tabular、longtable 或嵌套表。

Series.to_markdown([buf, mode, index, ...])

以 Markdown 友好的格式打印 Series。