day23学习Pandas库

三、Pandas库

3、内置的数据结构

3.2 DataFrame（二维数据结构）

3.2.4删除数据列

通过drop方法删除 DataFrame 中的数据，默认情况下，drop() 不会修改原 DataFrame，而是返回一个新的 DataFrame。

语法：

DataFrame.drop(labels=None, axis=0, index=None, 
columns=None, level=None, inplace=False, errors='raise')

参数：

1. labels：
   • 指定删除的列或行名字
2. axis：
   • 0代表是删除行名，1代表是删除列名，默认0
3. index：
   • 类型：单个标签或列表，默认为 None。
   • 描述：要删除的行的标签。如果指定，则忽略 labels 参数。
4. columns：
   • 类型：单个标签或列表，默认为 None。
   • 描述：要删除的列的标签。如果指定，则忽略 labels 参数。
5. level：
   • 类型：整数或级别名称，默认为 None。
   • 描述：用于多级索引（MultiIndex），指定要删除的级别。
6. inplace：
   • 是否在原 DataFrame直接修改，而不是返回一个新的 DataFrame。默认为 False
7. errors：
   • 类型：字符串，默认为 ‘raise’。
   • 描述：指定如何处理不存在的标签。‘raise’ 表示抛出错误，‘ignore’ 表示忽略错误。

示例：

import pandas as pd
result = pd.DataFrame()# 创建空对象
result['one'] = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']) # 添加新列
result['two'] = pd.Series([5, 6, 7, 8], index=['a', 'b', 'c', 'd']) # 添加新列
# 删除 列名为one 的列
result1 = result.drop(['one'],axis=1)
print(result1)
# 输出two
a    5
b    6
c    7
d    8

3.2.5行索引操作

1. df.loc[]根据标签获取数据

df.loc[]传标签索引，取值左闭右闭

• loc方法返回的数据类型：

1.如果选择单行或单列，返回的数据类型为Series

2.选择多行或多列，返回的数据类型为DataFrame

3.选择单个元素(某行某列对应的值)，返回的数据类型为该元素的原始数据类型（如整数、浮点数等）。

语法：

DataFrame.loc[row_indexer, column_indexer]

参数：

• row_indexer：行标签或布尔数组。
• column_indexer：列标签或布尔数组。

示例：

import pandas as pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4],'B': [5, 6, 7, 8],'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])# 使用 loc 选择数据
print(df.loc['a', 'B'])  # 取行标签为 'a'，列标签为 'B' 的元素/单个值
print(df['A'].loc['a'])  # 取列A ，行a  的值print(df.loc['a'])  # 取行'a'/单行print(df.loc['a':'c'])  # 取行'a' 到 行'c' /多行print(df.loc[['a', 'c'], ['A', 'C']]) # 取行'a'和行'c'，列'A'和列'C' 的数据/多行多列

输出：

5
1A    1
B    5
C    9
Name: a, dtype: int64A  B   C
a  1  5   9
b  2  6  10
c  3  7  11A   C
a  1   9
c  3  11

2. df.iloc[]根据下标获取数据

通过行和列的整数位置来选择数据。左闭右开

语法：

DataFrame.iloc[row_indexer, column_indexer]

参数：

• row_indexer：行位置或布尔数组。
• column_indexer：列位置或布尔数组。

案例：

import pandas as pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4],'B': [5, 6, 7, 8],'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])print(df.iloc[[0, 2], [0, 2]])  # 选择第 0 和 2 行，第 0 和 2 列的数据
# 输出A   C
a  1   9
c  3  11

3.df.loc添加新行

新添加的行长度 === 原行长度; iloc属性不能添加新列

示例：

import pandas as pd
# 创建一个示例 DataFrame
data = {'A': [1],'B': [3],'C': [5]
}
df = pd.DataFrame(data, index=['a'])
print(df)
print("==========================")
df.loc['e'] = [2,4,6]   # 添加新行
print(df)

输出:

   A  B  C
a  1  3  5
==========================A  B  C
a  1  3  5
e  2  4  6

4. concat拼接

语法：

pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)

参数：

objs: 要连接的 DataFrame 或 Series 对象(存放在列表或字典)

axis: 指定连接的轴，0 或 ‘index’ 表示按行连接，1 或 ‘columns’ 表示按列连接。

join: 指定连接方式，‘outer’ 表示并集（默认），‘inner’ 表示交集。

ignore_index: 如果为 True，则忽略原始索引并生成新的索引。

keys: 用于在连接结果中创建层次化索引。

levels: 指定层次化索引的级别。

names: 指定层次化索引的名称。

verify_integrity: 如果为 True，则在连接时检查是否有重复索引。

sort: 如果为 True，则在连接时对列进行排序。

copy: 如果为 True，则复制数据。

示例：

import pandas as pd
# 创建两个示例 DataFrame
df1 = pd.DataFrame({'A': pd.Series([1, 2, 3],index=['a', 'b', 'c']),'B': pd.Series([4, 5, 6],index=['a', 'b', 'c']),
})df2 = pd.DataFrame({'C': pd.Series([1, 2, 3], index=['a', 'b', 'c']),'D': pd.Series([7, 8, 9], index=['a', 'b', 'c']),
})
# 行合并，默认取并集（看列标签），ignore_index=True是 格式化行标签
df3 = pd.concat([df1,df2], axis=0, ignore_index=True)
print(df3)# 列合并，默认取并集（看行标签），ignore_index=True是 格式化列标签
df3 = pd.concat([df1,df2], axis=1, ignore_index=True)
print(df3)

输出：

     A    B    C    D
0  1.0  4.0  NaN  NaN
1  2.0  5.0  NaN  NaN
2  3.0  6.0  NaN  NaN
3  NaN  NaN  1.0  7.0
4  NaN  NaN  2.0  8.0
5  NaN  NaN  3.0  9.00  1  2  3
a  1  4  1  7
b  2  5  2  8
c  3  6  3  9

4.函数计算

1.常用的统计学函数

函数名称	描述说明
count()	统计某个非空值的数量
sum()	求和
mean()	求均值
median()	求中位数
std()	求标准差
min()	求最小值
max()	求最大值
abs()	求绝对值
prod()	求所有数值的乘积
var()	求方差(样本方差)

示例：

import pandas as pd
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50],'C': [100, 200, 300, 400, 500]
}
df = pd.DataFrame(data)
print(df.var())
# 输出
A        2.5 # ( (5-3)**2+(4-3)**2 ) * 2 / (5-1)
B      250.0
C    25000.0
dtype: float64

2.重置索引 df.reindex()

• 重置索引的顺序

• 如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。（添加新索引）

语法：

DataFrame.reindex(labels=None, index=None, columns=None, 
axis=None, method=None, copy=True, level=None, 
fill_value=np.nan, limit=None, tolerance=None)

参数：

1. labels：
   • 类型：数组或列表，默认为 None。
   • 描述：新的索引标签。
2. index：
   • 类型：数组或列表，默认为 None。
   • 描述：新的行索引标签。
3. columns：
   • 类型：数组或列表，默认为 None。
   • 描述：新的列索引标签。
4. axis：
   • 类型：整数或字符串，默认为 None。
   • 描述：指定重新索引的轴。0 或 ‘index’ 表示行，1 或 ‘columns’ 表示列。
5. method：
   • 类型：字符串，默认为 None。
   • 描述：用于填充缺失值的方法。可选值包括 ‘ffill’（前向填充）、‘bfill’（后向填充）等。
6. copy：
   • 类型：布尔值，默认为 True。
   • 描述：是否返回新的 DataFrame 或 Series。
7. level：
   • 类型：整数或级别名称，默认为 None。
   • 描述：用于多级索引（MultiIndex），指定要重新索引的级别。
8. fill_value：
   • 类型：标量，默认为 np.nan。
   • 描述：用于填充缺失值的值。
9. limit：
   • 类型：整数，默认为 None。
   • 描述：指定连续填充的最大数量。
10. tolerance：
    • 类型：标量或字典，默认为 None。
    • 描述：指定重新索引时的容差。

示例：

# 创建一个示例 DataFrame
import pandas as pddata = {'A': [1, 2, 3],'B': [4, 5, 6],'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
new_index = ['a', 'b', 'c', 'd']
# 重置行索引，新增行 d ，并用0填充
df_reindexed = df.reindex(index=new_index, fill_value=0)
print(df_reindexed)

输出

   A  B  C
a  1  4  7
b  2  5  8
c  3  6  9
d  0  0  0

3.遍历

未完待续…