本文详述了pandas库中pd.Series的创建、属性与方法，包括创建方法、属性（如index、value、shape等）、数据处理（如转换、排序、缺失值处理）以及索引、切片和布尔索引等操作。重点介绍了Series的常用方法，如head/tail、describe、sort_values/index、astype、apply、统计方法等。
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
- 引言
- 一 pd.Series的创建
- 二 pd.Series的常用属性与方法
- 1 pd.Series的常用属性
- 2 pd.Series的常用方法
- （1）基本方法
- （2） 排序
- （3）数据处理（转换）
- s.astype(dtype) ---- 转换 Series 的数据类型。有返回值，无inplace参数。
- .to_list() ---- 将 Series 转换为 Python 列表。
- .to_numpy(): 将 Series 转换为 NumPy 数组。
- .to_frame(name='col_name') --- 将 Series 转换为 DataFrame。name='col_name'指定列名
- .reset_index() ----- 重置索引
- 缺失值处理
- s .drop(index) ---- 删除指定索引行
- 高级用法（.apply(func)）---- 元素级操作，将指定函数应用于 Series 中的每个元素，并返回结果。
- 统计方法
- .sum(): 返回所有元素的和。
- .mean(): 返回所有元素的均值。
- .median(): 返回所有元素的中位数。
- .std(): 返回样本标准差。
- .var(): 返回样本方差。
- .min(): 返回最小值。
- .max(): 返回最大值。
- .quantile(q=0.5, interpolation='linear'): 返回第 q 个分位数值。
- .mad(): 返回平均绝对偏差。
- .corr(other, method='pearson', min_periods=None): 计算与另一 Series 的相关系数。
- .cov(other, min_periods=None, ddof=1): 计算与另一 Series 的协方差。
- .count(level=None): 计算非 NA/null 值的数量
- .cumsum(axis=0, skipna=True): 返回累积和
- .cumprod(axis=0, skipna=True): 返回累积积
- （4） 空series及其判断
- 三 series的访问、索引、切片、布尔索引等操作
引言
本部分主要介绍一些注意事项。
一 pd.Series的创建
pd.Series（data,index,dtype）---- 创建一维pd.Series;特别是其中的通过字典创建
pd.Series 的主要参数有以下几个：
-
data：Series 的数据，可以是列表、数组、字典等。如果是字典，字典的键将成为 Series 的索引，字典的值将成为 Series 的数据。
-
index：用于指定 Series 的索引，可以是列表、数组、索引对象（如
pd.Index对象）、标量或者 None。如果不提供索引，将默认使用从 0 开始的整数索引。 -
dtype：指定 Series 的数据类型。如果不指定，将根据数据类型推断。
下面是一些示例：
示例1：不定义index
# 通过列表创建 Series,不定义index会自动生成0....index
data = [1, 2, 3, 4, 5]
s = pd.Series(data)
print(s) # 0 1
# 1 2
# 2 3
# 3 4
# 4 5
# dtype: int64
示例2：自定义index
data = [1, 2, 3, 4, 5]
# 自定义索引
index = ['a', 'b', 'c', 'd', 'e']
s = pd.Series(data, index=index)
print(s)
# a 1
# b 2
# c 3
# d 4
# e 5
# dtype: int64
示例3：通过字典创建
# 通过字典创建 Series
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
s = pd.Series(data)
print(s)
# a 1
# b 2
# c 3
# d 4
# e 5
# dtype: int64
二 pd.Series的常用属性与方法
1 pd.Series的常用属性
s.index ---- 返回值是一个index对象，需要用 to_list()或to_numpy()转换过去
s.value ---- 返回值是一个 numpy数组
s.shape ---- 形状
s.size ---- 元素总数
s.dtype
在pandas里面 str 数据类型也是用 object表示的
在 Pandas 中，dtype: object 表示该列或 Series 中包含了一种通用的对象类型。通常，object 数据类型用于存储字符串，但它也可以存储其他类型的对象，例如列表、字典，甚至是混合类型的数据。
# 通过字典创建 Series
data_int = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
data_str = {'a': 'apple', 'b': 'banana', 'c': 'cat', 'd': 'dog', 'e': 'elephant'}
data_obj = {'a': 1, 'b': 'banana', 'c': 3, 'd': 'dog', 'e': 5}
int_ = pd.Series(data_int)
str_ = pd.Series(data_str)
obj_ = pd.Series(data_obj)
print(int_)
# a 1
# b 2
# c 3
# d 4
# e 5
# dtype: int64
print(str_)
# a apple
# b banana
# c cat
# d dog
# e elephant
# dtype: object
print(obj_)
# a 1
# b banana
# c 3
# d dog
# e 5
# dtype: object
# 属性（部分）
print(int_.dtype) # int64
print(str_.dtype) # object
print(obj_.dtype) # object
s.ndim ---- 一维数组维数，永远是1
# 通过字典创建 Series
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
s = pd.Series(data)
print(s.dtype) # int64
print(s.shape) # (5,) pd.Series 是一维数组
print(s.index) # Index(['a', 'b', 'c', 'd', 'e'], dtype='object') 这是一个索引对象
print(s.values) # [1 2 3 4 5] 这是一个numpy数组
print(s.ndim) # 1 永远是1
print(s.size) # 5 元素个数
2 pd.Series的常用方法
（1）基本方法
s.head() — 默认是查看前5行
s.tail() — 默认是查看后5行
# 通过字典创建 Series
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
s = pd.Series(data)
print(s.head(2)) # a 1
# b 2
# dtype: int64
print(s.tail(2)) # e 5
# f 6
# dtype: int64
s.describe() — 生成描述性统计信息
# 通过字典创建 Series
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
s = pd.Series(data)
print(s.describe())
# count 6.000000
# mean 3.500000
# std 1.870829
# min 1.000000
# 25% 2.250000
# 50% 3.500000
# 75% 4.750000
# max 6.000000
# dtype: float64
s.unique() ---- 返回 Series 中唯一值的numpy数组
# 通过字典创建 Series
data = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 5}
s = pd.Series(data)
print(s.unique()) # [1 2 3 4 5] numpy.ndarray
（2） 排序
s.sort_values(ascending=True) ------ 根据值排序
s.sort_index(ascending=True) ------ 根据索引排序
# 通过字典创建 Series
data = {'f': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'a': 1}
s = pd.Series(data)
print(s.sort_values()) # 按值排序
# f 1
# a 1
# b 2
# c 3
# d 4
# e 5
# dtype: int64
print(s.sort_index()) # 按索引排序
# a 1
# b 2
# c 3
# d 4
# e 5
# f 1
# dtype: int64
- 按值排序：Series 中的值按照升序排列，索引随之重新排列。
- 按索引排序：Series 中的索引按照字母顺序进行排列，对应的值随之重新排列。
s.rank(method=‘average’, na_option=‘keep’, ascending=True): 返回每个元素的排名。— 待更新
待更新
（3）数据处理（转换）
s.astype(dtype) ---- 转换 Series 的数据类型。有返回值，无inplace参数。
如果是 object 数据类型转换会报错。
data = {'f': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'a': 1}
s = pd.Series(data)
print(s.astype(float)) # f 1.0
# b 2.0
# c 3.0
# d 4.0
# e 5.0
# a 1.0
# dtype: float64
.to_list() ---- 将 Series 转换为 Python 列表。
# 通过字典创建 Series
data = {'f': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'a': 1}
s = pd.Series(data)
print(s.to_list()) # [1, 2, 3, 4, 5, 1] value to list
print(s.index.to_list()) # ['f', 'b', 'c', 'd', 'e', 'a'] index to list
.to_numpy(): 将 Series 转换为 NumPy 数组。
# 通过字典创建 Series
data = {'f': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'a': 1}
s = pd.Series(data)
print(s.to_numpy()) # [1 2 3 4 5 1]
print(s.index.to_numpy()) # ['f' 'b' 'c' 'd' 'e' 'a']
# 另外s.values本来返回的就是numpy数组
.to_frame(name=‘col_name’) — 将 Series 转换为 DataFrame。name='col_name’指定列名
# 通过字典创建 Series
data = {'f': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'a': 1}
s = pd.Series(data)
# 将 Series 转换为 DataFrame，并指定新的列名
df = s.to_frame(name='col_name')
print(df) # col_name
# f 1
# b 2
# c 3
# d 4
# e 5
# a 1
.reset_index() ----- 重置索引
使用 reset_index() 方法重置索引。
比较常用，有时通过布尔过滤选择数据返回的数据index是乱的，我们调用这个方法，index就会重新编号成0,1,2…
【注】：需要传入drop=True表明丢弃原来的索引，反之效果看下面代码给演示一下吧，不是很好叙述。
【注】：可以设置 inplace = True 改为原地操作（不过慎用 inplace，危险操作，开发中极有可能将你原始数据修改了）
# 创建一个示例 Series
s = pd.Series([3, 1, 2, 4, 5])
s = s[s >= 3]
print(s) # 0 3
# 3 4
# 4 5
# dtype: int64
# 重新设置索引，并丢弃原始索引
s_reset = s.reset_index(drop=True)
# s.reset_index(drop=True, inplace=True) # 原地操作
print(s_reset) # 0 3
# 1 4
# 2 5
# dtype: int64
【注】：如果不设置drop=True就会将原来索引保持下来，并当成Dataframe的一列保存下来，因此会返回一个Dataframe，像下面这样：
【注】：Dataframe里面也要 .reset_index(drop=True,inplace=True)
【注】：set_index()只有dataframe有，series没有
缺失值处理
s.isnull() — 返回一个布尔数组，指示每个元素是否为 NaN。
# 创建一个含有缺失值的 Series
s_with_nan = pd.Series([1, 2, None, 4, 5])
print(s_with_nan)
# 检测缺失值，返回一个布尔series
print(s_with_nan.isnull()) # 0 False
# 1 False
# 2 True
# 3 False
# 4 False
# dtype: bool
# 结合布尔过滤就能返回缺失值的数据了
print(s_with_nan[s_with_nan.isnull()]) # 2 NaN
# dtype: float64
s.fillna(value=None, method=None) ---- 用指定值或方法填充 NaN。
填充方法有 使用固定值，向前填充和向后填充三种方法。
# 创建一个含有 NaN 的 Series
s = pd.Series([1, 2, None, 4, None, 6])
# 用指定值填充 NaN
# filled_s = s.fillna(0) 也是一样的
filled_s = s.fillna(value=0)
## 用向前填充的方法填充 NaN
# filled_s = s.fillna(method='ffill')
## 用向后填充的方法填充 NaN
# filled_s = s.fillna(method='bfill')
print(filled_s)
s.dropna(): 删除包含 NaN 的行。
s_dropped = s_with_nan.dropna()
s .drop(index) ---- 删除指定索引行
# 创建一个示例 Series
data = {'a': 1, 'b': 2, 'c': 3}
s = pd.Series(data)
print(s) # a 1
# b 2
# c 3
# dtype: int64
# 删除索引为 'b' 的元素
new_s = s.drop('b')
print(new_s) # a 1
# c 3
# dtype: int64
高级用法（.apply(func)）---- 元素级操作，将指定函数应用于 Series 中的每个元素，并返回结果。
# 创建 Series
s = pd.Series([1, 2, 3, 4, 5])
# 使用 apply 方法和 lambda 匿名函数，对每个元素进行平方操作
s_applied = s.apply(lambda x: x ** 2)
print(s_applied) # 0 1
# 1 4
# 2 9
# 3 16
# 4 25
# dtype: int64
def f(x):
return x**2
# 创建 Series
s = pd.Series([1, 2, 3, 4, 5])
# 使用 apply 方法和 自定义的函数
s_applied = s.apply(f)
print(s_applied) # 0 1
# 1 4
# 2 9
# 3 16
# 4 25
# dtype: int64
统计方法
.sum(): 返回所有元素的和。
.mean(): 返回所有元素的均值。
.median(): 返回所有元素的中位数。
.std(): 返回样本标准差。
.var(): 返回样本方差。
.min(): 返回最小值。
.max(): 返回最大值。
.quantile(q=0.5, interpolation=‘linear’): 返回第 q 个分位数值。
.mad(): 返回平均绝对偏差。
.corr(other, method=‘pearson’, min_periods=None): 计算与另一 Series 的相关系数。
.cov(other, min_periods=None, ddof=1): 计算与另一 Series 的协方差。
.count(level=None): 计算非 NA/null 值的数量
.cumsum(axis=0, skipna=True): 返回累积和
.cumprod(axis=0, skipna=True): 返回累积积
（4） 空series及其判断
import pandas as pd
# 创建一个空的 Series
empty_series = pd.Series()
print(empty_series)
# 判断 Series 是否为空
if empty_series.empty:
print("Series 是空的。")
else:
print("Series 不是空的。")
输出：
三 series的访问、索引、切片、布尔索引等操作
1 索引访问、整数数组访问
# 创建Series
data = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6}
s = pd.Series(data)
# 访问数据
print('自定义index访问单个元素：,'s['a']) # 访问单个元素,返回的类型就是里面数据类型 1
print('位置索引访问单个元素：',s[1]) # 也可以通过位置索引访问，,返回的类型就是里面数据类型 2
print('索引列表访问多个元素1：\n',s[['a', 'b', 'c']]) # 通过索引列表访问多个元素，返回的数据类型（包括一条数据）都是pd.Series
# a 1 # b 2 # c 3 # dtype: int64
【注】：需要注意的就是仅取一个数据时的数据类型是什么；以及索引列表是不支持位置index的，只支持具体的index(除非就是使用默认的位置索引作为索引)
2 切片
【注】：位置索引切片（左闭右开）和自定义索引切片都支持（左闭右闭）
# 创建Series
data = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6}
s = pd.Series(data)
# 切片至少会有两个数据吧，所以类型一定是pd.Series
print(s[1:3]) # b 2
# c 3
# dtype: int64
print(s['b':'d']) # b 2
# c 3
# d 4
# dtype: int64
3 布尔数组索引访问
# 创建Series
data = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6}
s = pd.Series(data)
print('s>2',s[s > 2]) # c 3
# d 4
# e 5
# f 6
# dtype: int64
print('s==2',s[s == 2])
# b 2
# dtype: int64
4 loc 与 iloc
其实用法包含了前面1,2，3;会了loc与iloc就能做到前面1,2，3一样的，里面功能一模一样，只是调用方式不同而已
在 Pandas 中，Series 对象的 loc[] 和 iloc[] 方法用于选择和过滤数据。以下是它们的详细说明和用法：
loc[] 方法
loc[] 方法是基于标签（标签索引）的选择方法。可以使用标签索引来访问和过滤数据。
用法：
（1）.单个标签选择： series.loc[label]
（2）.标签列表选择： series.loc[[label1, label2, …]]
（3）.标签范围选择： series.loc[label1:label2]
（4）.布尔数组选择： series.loc[boolean_array]
创建一个 Series
data = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])
单个标签选择
print(data.loc['b']) # 20
标签列表选择
print(data.loc[['b', 'd']]) # b 20
# d 40
# dtype: int64
标签范围选择
print(data.loc['b':'d']) # b 20
# c 30
# d 40
# dtype: int64
布尔数组选择
print(data.loc[data>20]) # c 30
# d 40
# e 50
# dtype: int64
汇总
data = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])
print(data.loc['b']) # 20
print(data.loc[['b', 'd']]) # b 20
# d 40
# dtype: int64
print(data.loc['b':'d']) # b 20
# c 30
# d 40
# dtype: int64
print(data.loc[data>20]) # c 30
# d 40
# e 50
# dtype: int64
iloc[] 方法
iloc[] 方法是基于整数位置的选择方法。使用整数位置来访问和过滤数据。
用法：
（1）.单个整数位置选择： series.iloc[position]
（2）.整数位置列表选择： series.iloc[[position1, position2, …]]
（3）.整数位置范围选择： series.iloc[start:stop]
（4）.布尔数组选择： series.iloc[boolean_array]
创建一个 Series
data = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])
单个整数位置选择
print(data.iloc[1]) # 20
整数位置列表选择
print(data.iloc[[1, 3]]) # b 20
# d 40
# dtype: int64
整数位置范围选择
print(data.iloc[1:4]) # b 20
# c 30
# d 40
# dtype: int64
[注]：自定义index都是左闭右闭，默认位置index是左闭右开。
iloc不支持series布尔数组选择，只支持布尔列表,布尔numpy数组等布尔访问
因为 loc和iloc设计上的不同，loc支持series布尔索引，iloc不支持series布尔索引，只能使用 s[s>20]或者先转换成布尔列表在布尔访问。下面给出来几种解决方法。
data = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])
print(data[data>20]) # c 30
# d 40
# e 50
# dtype: int64
index: pd.Series = data>20
print(data[index.to_list()]) # c 30
# d 40
# e 50
# dtype: int64
print(data[index.values]) # values属性本身就是一个numpy数组所以也可以这样
# c 30
# d 40
# e 50
# dtype: int64
print(data.iloc[data>20]) # ValueError: iLocation based boolean indexing cannot use an indexable as a mask
# 应为 data>20返回的是一个布尔Series，iloc不支持布尔Series索引，可以将其转换为布尔列表
汇总
data = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])
print(data.iloc[1]) # 20
print(data.iloc[[1, 3]]) # b 20
# d 40
# dtype: int64
print(data.iloc[1:4]) # b 20
# c 30
# d 40
# dtype: int64
【注意事项】
（1）.loc[] 基于标签索引，如果标签是整数，则必须传递标签值，而不是位置。
（2）.iloc[] 基于整数位置，无论索引是什么类型，都可以使用整数位置进行访问。
（3）.使用布尔数组进行loc选择时，数组的长度必须与 Series 的长度一致。
5 at[],iat[],get() — 待更新
at[]: 获取单个标签位置的标量值。
iat[]: 获取单个整数位置的标量值。
get(key, default=None): 根据标签获取值，如果标签不存在则返回默认值。
待更新 ---- 这块暂时用的不多，后面在更新
6 使用索引访问等修改Series — 待更新
待更新
扫一扫
699
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
