pandas是含有使数据分析工作变得更快更简单的高级数据结构和操作工具。pandas是基于NumPy构建的，让以NumPy为中心的应用变得更加简单。
导入pandas
from pandas import Series, DataFrame
import pandas as pd
# 导入 Series 和 DataFrame,可以直接使用 Series() 和 DataFrame() 函数来创建 Series 和
# DataFrame 对象了，而无需在代码中使用 pd. 前缀。
from pandas import Series, DataFrame
import pandas as pd
Pandas主要有两种数据结构：Series和DataFrame
一 、Series：
1.1 创建
= pd.Series([, , ,])
Series是一维标记数组，类似于Python中的列表或数组。它由一组数据和一组与之相关的索引（标签）组成。
import numpy as np
import pandas as pd
# 创建Series
obj = pd.Series([1, 2, 3, 4, 5])
输出：
goCopy code
0 1
1 2
2 3
3 4
4 5
dtype: int64
1.2 索引
1.2.1 介绍
- Series的字符串表现形式为:索引在左边，值在右边。由于没有为数据指定索引，于是会自动创建一个0到N-1(N为数据的长度)的整数型索引。
- 访问：可以通过Series的values和index属性获取其数组表示形式和索引对象:
- obj.index ， obj.values
# 访问 Series 的值
values = obj.values
print("Series 的值：", values)
# 访问 Series 的索引
index = obj.index
print("Series 的索引：", index)
输出
Series 的值： [1 2 3 4 5]
Series 的索引： RangeIndex(start=0, stop=5, step=1)
1.2.2 显示索引(自定义索引)
定义：希望所创建的Series带有一个可以对各个数据点进行标记的索引:
pd.Series(data, index=index)
pd.Series([, , ,], index=[, , ,])
import pandas as pd
# 创建数据
data = [10, 20, 30, 40, 50]
index = ['A', 'B', 'C', 'D', 'E']
# 创建Series
series_custom_index = pd.Series(data, index=index)
# 或者写
#series_custom_index = pd.Series([10, 20, 30, 40, 50], index=['A', 'B', 'C', 'D', 'E'])
输出将是：
A 10
B 20
C 30
D 40
E 50
dtype: int64
访问 ：与普通的NumPy数组相比，Series中的单个或一组值可以通过索引的方式选取。
obj2['a'] 、obj2[['c', 'a', 'd']]
修改：obj2['d'] = 6
obj2['a']
# 输出: -5
obj2['d'] = 6
obj2[['c', 'a', 'd']]
# 输出：
# c 3
# a -5
# d 6
# dtype: int641.3 数组运算
在 Pandas 中，Series 对象的数组运算通常会保留索引和值之间的链接。这意味着，对 Series 进行过滤、标量乘法、应用数学函数等操作后，Series 的索引与值之间的对应关系仍然保持不变。
1.3.1 加、减、乘、除 （元素间）
import pandas as pd
# 创建两个Series对象
s1 = pd.Series([1, 2, 3, 4])
s2 = pd.Series([5, 6, 7, 8])
# 加法
result_add = s1 + s2
print("加法结果：")
print(result_add)
# 输出：
# 0 6
# 1 8
# 2 10
# 3 12
# dtype: int64
# 减法
result_sub = s1 - s2
print("\n减法结果：")
print(result_sub)
# 输出：
# 0 -4
# 1 -4
# 2 -4
# 3 -4
# dtype: int64
# 乘法
result_mul = s1 * s2
print("\n乘法结果：")
print(result_mul)
# 输出：
# 0 5
# 1 12
# 2 21
# 3 32
# dtype: int64
# 除法
result_div = s1 / s2
print("\n除法结果：")
print(result_div)
# 输出：
# 0 0.200000
# 1 0.333333
# 2 0.428571
# 3 0.500000
# dtype: float64
# 平方根
result_sqrt = s1.apply(lambda x: x ** 0.5)
print("\n平方根结果：")
print(result_sqrt)
# 输出：
# 0 1.000000
# 1 1.414214
# 2 1.732051
# 3 2.000000
# dtype: float641.3.2 应用数学函数
写法1： = np.log(s)
写法2： = s.apply(np.log)
# 1.应用数学函数
result_sqrt = s.apply(np.sqrt) # 平方根
result_exp = s.apply(np.exp) # 指数函数
result_log = s.apply(np.log) # 自然对数
result_sin = s.apply(np.sin) # 正弦函数
# 2. 应用数学函数
result_sqrt = np.sqrt(s) # 平方根
result_exp = np.exp(s) # 指数函数
result_log = np.log(s) # 自然对数
result_sin = np.sin(s) # 正弦函数1.3.3 布尔型数组进行过滤
s[s > 2]
import pandas as pd
# 创建一个 Series 对象
s = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
print("原始 Series 对象：\n", s)
# 创建一个布尔型数组，用于过滤
mask = s > 2
print("布尔型数组：\n", mask)
'''
布尔型数组：
a False
b False
c True
d True
e True
dtype: bool
'''
# 根据布尔型数组进行过滤
filtered_s = s[mask]
print("过滤后的 Series 对象：\n", filtered_s)
'''
过滤后的 Series 对象：
c 3
d 4
e 5
dtype: int64
'''
布尔型数组 mask 用于过滤 Series 对象 s 中大于 2 的元素。
Series 对象可以看作是一个定长的有序字典，因为它将索引值映射到数据值。因此，你可以使用类似于字典的方式来操作 Series 对象，包括检查索引是否存在于 Series 中。
'b' in obj2 返回 True，表明索引值 'b' 存在于 obj2 中；而 'e' in obj2 返回 False，表明索引值 'e' 不存在于 obj2 中。
In[18]:'b'in obj2 Out[18]: True In[19]:'e'in obj2 0ut[19]:False
1.4 字典
1.4.1 检查索引是否存在
使用索引值来检查是否存在于该Series对象中。由于Series对象类似于一个有序字典，因此可以像字典一样使用in运算符来检查索引是否存在。
'索引' in obj2
import pandas as pd
# 创建一个 Series 对象
obj2 = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
# 检查索引是否存在于 Series 中
print("'b' in obj2:", 'b' in obj2) # 应该输出 True
print("'e' in obj2:", 'e' in obj2) # 应该输出 False1.4.2 通过字典来创建Series
如果数据被存放在一个Python字典中，也可以直接通过这个字典来创建Series
pd.Series({‘索引’：数据，‘索引’：数据，‘索引’：数据})
import pandas as pd
# 创建一个Python字典，键是州名，值是对应的数据
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
# 使用Python字典创建Series对象
obj3 = pd.Series(sdata)
# 打印Series对象
print(obj3)
输出结果：
Ohio 35000
Texas 71000
Oregon 16000
Utah 5000
dtype: int64
如果只传入一个字典，则结果Series中的索引就是原字典的键(有序排列)
1.4.3 按指定顺序创建Series
可以将字典键按照你想要的顺序传入构造函数，就能确保Series对象的索引按照指定的顺序排列。
pd.Series({‘索引’：数据，‘索引’：数据，‘索引’：数据}，index = )
import pandas as pd
# 按照你想要的顺序排列字典键
desired_order = ['California', 'Ohio', 'Oregon', 'Texas']
# 创建一个字典
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000}
# 将字典键按照指定顺序传入构造函数
obj4 = pd.Series(sdata, index=desired_order)
# 输出结果
print(obj4)California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
dtype: float64sdata中跟states索引相匹配的那3个值会被找出来并放到相应的位置上，但由于“california”所对应的sdata值找不到，所以其结果就为NaN(即“非数字(notanumber)，在pandas中，它用于表示缺失或NA值)。将使用缺失(missing)或NA表示缺失数据。
1.4.4 isnull和notnull
pandas的isnull和notnull函数可用于检测缺失数据
pd.isnull(Series对象)
pd.nonull(Series对象)
import pandas as pd
# 创建一个Python字典，键是州名，值是对应的数据
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
# 指定Series对象的索引
states = ['California', 'Ohio', 'Oregon', 'Texas']
# 使用指定索引创建Series对象
obj4 = pd.Series(sdata, index=states)
# 使用isnull()函数检测缺失数据
print(pd.isnull(obj4))
# 使用notnull()函数检测缺失数据
print(pd.notnull(obj4))
输出结果：
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
dtype: float64
California True
Ohio False
Oregon False
Texas False
dtype: bool
California False
Ohio True
Oregon True
Texas True
dtype: bool
True 表示相应的值是缺失的，而 False 表示相应的值不是缺失的。isnull() 函数返回一个布尔型的Series，指示哪些值是缺失的，而 notnull() 函数则返回一个布尔型的Series，指示哪些值不是缺失的。
1.4.5 数据对齐
Series最重要的一个功能是:它在算术运算中会自动对齐不同索引的数据。
import pandas as pd
# 定义字典和索引列表
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
states = ['California', 'Ohio', 'Oregon', 'Texas']
# 使用字典创建Series，索引为字典的键
obj3 = pd.Series(sdata)
print(obj3)
# 使用字典创建Series，并指定索引，对应的值会自动对齐索引
obj4 = pd.Series(sdata, index=states)
print(obj4)
# 算术运算自动对齐不同索引的数据
print(obj3 + obj4)输出：
Ohio 35000
Texas 71000
Oregon 16000
Utah 5000
dtype: int64
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
dtype: float64
California NaN
Ohio 70000.0
Oregon 32000.0
Texas 142000.0
Utah NaN
dtype: float641.5 name属性
series 对象和索引都有name属性
# 创建一个 Series 对象，并设置名称
s = pd.Series([1, 2, 3, 4], name="MySeries")
# 设置索引的名称
s.index.name = "MyIndex"
# 输出 Series 对象和索引的名称
print("Series 对象的名称：", s.name)
print("索引的名称：", s.index.name)二、DataFrame
DataFrame是一个二维的、表格型的数据结构，类似于SQL中的表或Excel中的电子表格。它由行索引、列索引和数据组成，每列可以是不同的数据类型。
注意：尽管DataFrame是二维的，但可以通过分层索引在dataframe中展现更高维度的数据。
2.1 创建DataFrame
- 通过传入字典创建DataFrame，字典的键将作为列索引，字典的值可以是列表、数组、Series等。
- 通过传入列表字典创建DataFrame，列表字典中的每个字典都会被视为DataFrame的一行，字典的键将作为列索引。
- 通过传入Series字典创建DataFrame，Series字典中的每个Series对象都会被视为DataFrame的一列，字典的键将作为列索引。
- 通过传入二维数组（如numpy的ndarray）创建DataFrame，可以指定行索引和列索引。
2.1.1 传入字典创建
（1）字典 +列表
data = {'列索引': [, ，，],''列索引': [, ，，] }
df = pd.DataFrame(data)
import pandas as pd
# 传入字典创建DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago']}
df = pd.DataFrame(data)
print(df)输出结果：
Name Age City
0 Alice 25 New York
1 Bob 30 Los Angeles
2 Charlie 35 Chicago字典中的键被自动转换为DataFrame的列索引，而字典中的值则被自动转换为DataFrame的数据。
（2）serise +字典
通过传入Series字典创建DataFrame，Series字典中的每个Series对象都会被视为DataFrame的一列，字典的键将作为列索引。
index1= [, , , ]
serise对象 1= pd.Series([, , , ], index=index1)
serise对象 1= pd.Series([, , , ], index=index1)
= pd.DataFrame(data = {'列名1': serise对象1,'列名2': serise对象2})
import pandas as pd
# 创建数据
names = pd.Series(['Alice', 'Bob', 'Charlie', 'David', 'Emily'], index=['A', 'B', 'C', 'D', 'E'])
ages = pd.Series([25, 30, 35, 40, 45], index=['A', 'B', 'C', 'D', 'E'])
# 创建DataFrame
df = pd.DataFrame(data = {'name':names,'age': ages})
输出将是：
name age
A Alice 25
B Bob 30
C Charlie 35
D David 40
E Emily 45
（3）列表+字典
通过传入列表字典创建DataFrame，列表字典中的每个字典都会被视为DataFrame的一行，字典的键将作为列索引。
data = [
{' 列名1': , ' 列名2': , ' 列名3': },
{' 列名1': , ' 列名2': , ' 列名3': },
{' 列名1': , ' 列名2': , ' 列名3': },
]
df = pd.DataFrame(data)
# 创建一个列表字典
data = [
{'Name': 'Alice', 'Age': 25, 'City': 'New York'},
{'Name': 'Bob', 'Age': 30, 'City': 'Los Angeles'},
{'Name': 'Charlie', 'Age': 35, 'City': 'Chicago'}
]
# 通过传入列表字典创建DataFrame
df = pd.DataFrame(data)输出结果：
Name Age City
0 Alice 25 New York
1 Bob 30 Los Angeles
2 Charlie 35 Chicago2.1.2 传入二维数组创建
通过传入二维数组（如numpy的ndarray）创建DataFrame，可以指定行索引和列索引。
data = np.array([[, , ],[, , ],[, , ]])
= pd.DataFrame(data, index=index, columns=columns)
# 创建一个二维数组（ndarray）
data = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# 指定行索引和列索引
index = ['a', 'b', 'c']
columns = ['A', 'B', 'C']
# 通过传入二维数组创建DataFrame
df = pd.DataFrame(data, index=index, columns=columns)
print(df)输出结果：
A B C
a 1 2 3
b 4 5 6
c 7 8 92.2 索引
2.2.1 按指定列顺序排列
= pd.DataFrame(data, columns=['C','B','A'])
# 创建一个字典
data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago']
}
# 指定列的顺序排序
columns_order = ['City', 'Age', 'Name']
# 创建DataFrame，并指定列的顺序排序
df = pd.DataFrame(data, columns=columns_order)输出结果：
City Age Name
0 New York 25 Alice
1 Los Angeles 30 Bob
2 Chicago 35 Charlie创建DataFrame时指定了列的顺序，但是某些列不在数据中存在，那么这些列会显示为空（NaN）
import pandas as pd
# 创建一个字典，但不包含所有列
data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'City': ['New York', 'Los Angeles', 'Chicago']
}
# 指定列的顺序排序
columns_order = ['City', 'Age', 'Name']
# 创建DataFrame，并指定列的顺序排序
df = pd.DataFrame(data, columns=columns_order)
print(df)
#输出结果：
City Age Name
0 New York NaN Alice
1 Los Angeles NaN Bob
2 Chicago NaN Charlie2.2.2 列检索
（1）字典的标记方式
用类似字典的标记方式来选择DataFrame中的列，你可以直接使用列名作为DataFrame的键来访问对应的列。
df['City']
# 创建一个字典
data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago']
}
# 创建DataFrame
df = pd.DataFrame(data)
# 检索列为Series
name_series = df['Name']
age_series = df['Age']
city_series = df['City']
print("Name Series:")
print(name_series)
print("\nAge Series:")
print(age_series)
print("\nCity Series:")
print(city_series)
#输出结果：
Name Series:
0 Alice
1 Bob
2 Charlie
Name: Name, dtype: object（2）属性检索
使用属性检索方式访问DataFrame中的列，你可以直接使用点操作符，将列名作为DataFrame的属性。
df.City
# 使用属性检索方式选择列
name_series = df.Name
age_series = df.Age
city_series = df.City2.2.3 行检索
DataFrame中的行可以通过位置或者特殊属性进行选择。iloc属性和loc属性
（1）位置：
= df.iloc[0]
你可以使用iloc属性来按照行索引的位置选择行。这种方式类似于Python中的列表索引，从0开始。例如，df.iloc[0]会选择第一行，df.iloc[1]会选择第二行，依此类推。
# 创建一个字典
data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago']
}
# 创建DataFrame
df = pd.DataFrame(data, index=['a', 'b', 'c'])
# 通过位置选择行
row_by_position = df.iloc[0]
print("Row by Position:")
print(row_by_position)Row by Position:
Name Alice
Age 25
City New York
Name: a, dtype: object（2）特殊属性
= df.loc['row_label']
使用loc属性按照行标签选择行。这种方式更加灵活，你可以使用行标签来选择行。例如，df.loc['row_label']会选择具有指定行标签的行。
# 通过特殊属性选择行
row_by_label = df.loc['b']
print("\nRow by Label:")
print(row_by_label)Row by Label:
Name Bob
Age 30
City Los Angeles
Name: b, dtype: object2.4.1 列的修改和删除
(1) 修改列的值
直接对DataFrame中的列进行赋值操作来修改列的值。例如，df['Column'] = new_values会将列'Column'的值修改为new_values。
df['列名'] = [,, ]
# 直接赋值修改列名 df.columns = ['Full Name', 'Years Old', 'Location']
# 创建一个字典
data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago']
}
# 创建DataFrame
df = pd.DataFrame(data)
# 修改列
df['Age'] = [26, 31, 36]
print("Modified DataFrame:")
print(df)(2) 删除列
del df['Column']
df.drop('Column', axis=1, inplace=True)则会删除名为'Column'的列
可以使用del关键字或者drop()方法来删除DataFrame中的列。例如，del df['Column']会删除名为'Column'的列，而df.drop('Column', axis=1, inplace=True)则会删除名为'Column'的列，并且在原地修改DataFrame。
# 删除列
del df['City']
# 使用drop()方法删除列
df.drop('Name', axis=1, inplace=True)
# axis=1: 这是指定要删除的是列而不是行。axis=1表示要删除列，而axis=0表示要删除行。
# inplace=True: 这个参数表示是否在原地修改DataFrame，默认为False。
#如果设置为True，那么会直接在原来的DataFrame上进行操作，而不返回一个新的DataFrame对象。
#如果设置为False（默认值），则会返回一个新的DataFrame对象，原来的DataFrame不会被改变。
2.3 转置
df.T
DataFrame对象具有T属性，可用于转置DataFrame，即交换行和列。
# 转置DataFrame
df_transposed = df.T2.4 name 属性
DataFrame的名字 ： df.name = 'MyDataFrame'
索引的名字 df.index.name = 'Index Label'
列的名字 df.columns.name = 'Column Label'
2.5 values 属性
= df.values
values 属性用于返回 DataFrame 的值作为二维数组。这个属性返回的是 DataFrame 内部存储的数据，不包括索引和列标签。
# 获取 DataFrame 的值
df_values = df.values
[['Alice' 25 'New York']
['Bob' 30 'Los Angeles']
['Charlie' 35 'Chicago']]2.6 head()、tail() 方法
使用 head()、tail() 方法查看 DataFrame 的前几行或后几行。
head() 方法用于查看 DataFrame 的前几行，默认情况下显示前 5 行。tail() 方法用于查看 DataFrame 的后几行，默认情况下显示最后 5 行。你可以通过传入参数来指定要显示的行数。
# 查看 DataFrame 的前 3 行 df.head(3)
# 查看 DataFrame 的后 3 行 df.tail(3)
2.7 总结
下面是 DataFrame 的用法总结：
-
创建 DataFrame：
- 使用字典创建：通过传入字典来创建 DataFrame，字典的键将成为列名，字典的值可以是列表、数组等。
- 使用二维数组创建：通过传入二维数组来创建 DataFrame，可以指定行索引和列索引。
- 使用列表字典创建：通过传入列表字典来创建 DataFrame，列表字典中的每个字典将被视为 DataFrame 的一行。
- 使用 Series 字典创建：通过传入 Series 字典来创建 DataFrame，Series 字典中的每个 Series 对象将被视为 DataFrame 的一列。
-
访问 DataFrame：
- 查看数据：使用
head()、tail()方法查看 DataFrame 的前几行或后几行。 - 获取索引和列：使用
index和columns属性获取 DataFrame 的索引和列。 - 获取值：使用
values属性获取 DataFrame 的值。
- 查看数据：使用
-
操作 DataFrame：
- 增加和删除列：使用
df['NewColumn'] = values增加新列，使用del df['Column']或df.drop('Column', axis=1, inplace=True)删除列。 - 修改列名：使用
df.columns = new_columns修改列名，或者使用df.rename(columns={'old_name': 'new_name'}, inplace=True)方法。 - 设置索引：使用
set_index()方法设置索引。 - 转置 DataFrame：使用
T属性将 DataFrame 转置为行和列互换的形式。 - 排序：使用
sort_values()方法对 DataFrame 进行排序。 - 重置索引：使用
reset_index()方法重新设置 DataFrame 的索引。
- 增加和删除列：使用
-
数据选择和过滤：
- 根据位置选择：使用
iloc[]方法根据行和列的位置选择数据。 - 根据标签选择：使用
loc[]方法根据行和列的标签选择数据。 - 条件选择：使用布尔索引根据条件选择数据。
- 根据位置选择：使用
-
数据分析和统计：
- 描述统计：使用
describe()方法获取 DataFrame 的描述统计信息。 - 聚合操作：使用
groupby()方法对 DataFrame 进行分组聚合操作。 - 汇总统计：使用
sum()、mean()、median()等方法进行汇总统计。 - 缺失值处理：使用
isnull()、fillna()等方法处理 DataFrame 中的缺失值。
- 描述统计：使用
-
数据导入和导出：
- 导入数据：使用
read_csv()、read_excel()等方法从外部文件导入数据到 DataFrame。 - 导出数据：使用
to_csv()、to_excel()等方法将 DataFrame 中的数据导出到外部文件。
- 导入数据：使用
三、索引对象
Pandas 索引对象用于对数据进行索引、选择、切片和重塑等操作
3.1索引和选择
- 使用
[]运算符：可以使用[]运算符从 Series 或 DataFrame 中选择数据。可以传入单个标签、标签列表、切片、布尔数组等。 - 使用
.loc[]方法：.loc[]方法用于按标签进行索引和选择。可以传入单个标签、标签列表、切片、布尔数组等。 - 使用
.iloc[]方法：.iloc[]方法用于按位置进行索引和选择。可以传入单个位置、位置列表、切片、布尔数组等。 -
# 使用 [] 运算符选择数据 df['A'] # 选择列'A' df[['A', 'B']] # 选择列'A'和'B' df[1:3] # 选择行2到3 # 使用 .loc[] 方法按标签选择数据 df.loc['row1'] # 选择行'row1' df.loc[['row1', 'row3']] # 选择行'row1'和'row3' df.loc['row1':'row3'] # 选择行'row1'到'row3' df.loc[:, 'A':'B'] # 选择列'A'到'B' # 使用 .iloc[] 方法按位置选择数据 df.iloc[0] # 选择第一行 df.iloc[[0, 2]] # 选择第一行和第三行 df.iloc[0:3] # 选择第一行到第三行 df.iloc[:, 0:2] # 选择第一列到第二列3.2 重塑索引
- 重置索引：使用
.reset_index()方法可以将当前的索引重置为默认的整数索引，并将原来的索引作为新的列添加到 DataFrame 中。
# 重置索引 df_reset = df.reset_index()
- 设置新索引：使用
.set_index()方法可以设置新的索引，可以设置单个列为索引，也可以设置多个列为层次化索引。将 'new_index_column' 列设置为新的索引
# 设置新索引 df_new_index = df.set_index('new_index_column')
- 多级索引：使用
MultiIndex对象可以创建多级索引，用于多维数据的分组、筛选和聚合操作。
# 创建多级索引 df_multi_index = df.set_index(['level_1', 'level_2'])
3.3 索引对齐
在进行运算时，Pandas 会自动对齐不同索引的数据，如果索引不匹配，则会使用 NaN 填充缺失值。
3.4 索引对象的属性和方法
index：获取索引对象中的标签。name：获取或设置索引对象的名称。dtype：获取索引对象的数据类型。is_unique：检查索引对象中的标签是否唯一。is_monotonic：检查索引对象中的标签是否单调递增或单调递减。isin()：检查索引对象中的标签是否包含在给定的列表或数组中。append()：将两个索引对象连接成一个新的索引对象。
3.5 索引不可修改但可重复
3.5.1 不可修改
Pandas 中的索引对象是不可变的，这意味着一旦创建，就无法更改索引的值。这种不可变性确保了索引对象的稳定性和数据的一致性。虽然你可以重新创建一个新的索引对象来替换原有的索引，但是原有的索引对象本身是不可变的。
3.5.2 可重复
索引标签可以在索引对象中出现多次。这意味着在同一个索引对象中可以有相同的索引标签。这种情况在某些数据集中是常见的，特别是在多级索引中。
# 创建一个示例 Series，索引中包含重复的标签
data = [1, 2, 3, 4]
index = ['a', 'b', 'a', 'c'] # 索引中包含重复的标签 'a'
s = pd.Series(data, index=index)
print(s)
a 1
b 2
a 3
c 4
dtype: int64
# 使用索引标签 'a' 进行索引操作
result = s['a']
print(result)
a 1
a 3
dtype: int64
扫一扫
1729
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
