[学习随笔] Pandas入门

2025-04-27

本文使用语言：Python（有点多余了…）

创建DataFrame

从数组到DataFrame

二维数组可以通过pd.DataFrame(list_name)直接转为DataFrame,不输入参数时默认列名为range(0-n)

可以通过指定参数columns = <list>,index = <list>来修改列、行名，，其中<list>为python列表，如：

def createDataframe(student_data: List[List[int]]) -> pd.DataFrame:
    ans_df = pd.DataFrame(student_data,columns = ['id','age']) 
    return ans_df

输入格式如：[[1,15],[2,11],[3,11],[4,20]]

输出格式如：{"headers": ["id", "age"], "values": [[1, 15], [2, 11], [3, 11], [4, 20]]}

标准输出格式：（如print(df)）

对DataFrame的基本操作

查询形状

已知list_df是一个DataFrame，可以通过调用它的shape属性来获取其尺寸，返回对象类型是tuple

与之对比的是size属性。它返回的是具体内容的个数

players = [[1,20],[2,21],[3,22]]
players_df = pd.DataFrame(data = players, columns = ['Id', 'Age'])
print(player_df.shape) #----->(3,2) ## 有三行二列
print(player_df.size)  #----->6     ## 有六个元素（行列名未被算进去，统计占了多少“格子”

显示前x行

data_df.head(x) 可以显示该DataFrame的前x行

如果不传参，默认显示前5行

定位特定位置

有两种主要定位方式：基于标签与基于整数

基于标签：`loc`

其传入是基于标签的（传值也行），是包含结束位置的

其基本形式是df.loc[<indices>,<cols>],比如：

df.loc['A','B'] #A行B列
df.loc['A',['B','C']] #A行BC列
df.loc[:,'B'] #所有行B列
df.loc[df['B']==1,'C'] #列B值为1的所有行C列

Boolean遮罩

布尔遮罩是一个与DataFrame或Series形状相同的布尔数组（包含True和False），用于选择满足特定条件的行或列。遮罩中的True表示保留该位置的数据，False表示忽略。

使用过程是：

创建一个条件，生成布尔Series或数组。例如，df[‘B’] > 30会为每行生成True或False。
将布尔遮罩传递给索引方法（如.loc或直接索引），Pandas会返回True对应的数据。

注：关于多条件组合

可以使用~ & |连接不同条件进行“非、与、或”的操作，但不能用not and or，因为后者的作用对象是单个布尔值而非布尔数组

基于整数：`iloc`

其传入的是索引值，是不包含解释位置的

添加列

类似C++的vector，在列表中添加不存在的列时，直接声明即可。如data_df['new_col'] = data_df['col_1']*2

删除重复列

有方法df.drop_duplicates(subset,keep)

subset是要筛查的列，填None表示对所有列筛查
keep参数有'first','last',False来保留首次出现项、末次出现项、不保留
可以进一步补inplace=True来原地改进（但该指令不会直接返回，需要先执行，再返回df本身）

删除缺失行/列

有方法df.dropna(axis,how,thresh,subset,inplace)

axis 可以选0/1（0表示行筛选，1表示列筛选）
how 可以选'any','all',表示只要出现NA就删、全NA就删
thresh 表示若保留需要的的最小NA数量
subset如上

重命名行/列

有方法df.rename()，具体参数：

columns 传入字典，键为原名，值为所改名，处理列
index 同上，处理行
copy 设置为True会返回一个新的DataFrame
inplace 同上
errors 可设置为'raise','ignore'，分别表示遇到不存在的待命名项时是报错还是忽略

更改数据类型

有方法df.astype()，具体参数：

dtype 传入字典，键为待改列，值为所改数据类型
copy 同上
errors 同上，raise会在找不到列与新数据类型无效时报错
注，其无inplace参数

填充NA值

有方法df[<column>].fillna(),其作用对象是DataFrame与Series

具体参数有：

value 可传值，字典等。传值可定填充用值。当对DF用fillna时，选字典可对指定行/列统一fillna，键为列/行名，值为填充用值
method 可选'backfill', 'bfill', 'pad', 'ffill', None来定填充方式
axis 定轴
inplace

排序

有方法df.sort_values()，具体参数：

by 填依据的列的名字
ascending True表示升序，否则降序

透视（长格式表—>宽格式表）

这本质上是将长格式表转换为宽格式表的过程。长格式表将每个观测值数据单列一行，宽格式表将每组观测数据单列一行

长格式表：
Id      Variable1    Variable2     ...     Value
01         Math      Mid Term      ...      99
01         Math        Final       ...      98
01        English      Final       ...      96
02         Math      Mid Term      ...      89

宽格式表：
Id      Key1      Key2      ...
id      Value1    Value2    ...  

如:
Id      Math,Mid Term     Math,Final
01      99                98
01      89                88

有方法df1 = df.pivot(),具体参数：

index 填入列名，该列的每个唯一值将为新DataFrame建立一个行（也就是决定新DF的划分标准）
columns 确定新 DataFrame 中的列,透视表将有各数个列分别对应于所取列中的每个唯一值
values 确定填入表格的具体数据是什么

"""
weather =
| city         | month    | temperature |
| ------------ | -------- | ----------- |
| Jacksonville | January  | 13          |
| Jacksonville | February | 23          |
| Jacksonville | March    | 38          |
| Jacksonville | April    | 5           |
| Jacksonville | May      | 34          |
| ElPaso       | January  | 20          |
| ElPaso       | February | 6           |
| ElPaso       | March    | 26          |
| ElPaso       | April    | 2           |
| ElPaso       | May      | 43          |
"""
new_df = weather.pivot(index='month',columns = 'city',values = 'temperature')
"""
| month    | ElPaso | Jacksonville |
| -------- | ------ | ------------ |
| April    | 2      | 5            |
| February | 6      | 23           |
| January  | 20     | 13           |
| March    | 26     | 38           |
| May      | 43     | 34           |
"""

融合（宽格式表—>长格式表）

有方法：df.melt()，具体参数：

id_vars 保持不变的列（值可能会重复出现于多列，但内容不会变）
value_vars 一个id_var单子对应的不同变量的列表
var_name value_vars的标头的名称
value_name 值的名称

"""
report=
| product     | quarter_1 | quarter_2 | quarter_3 | quarter_4 |
| ----------- | --------- | --------- | --------- | --------- |
| Umbrella    | 417       | 224       | 379       | 611       |
| SleepingBag | 800       | 936       | 93        | 875       |
"""
df = report.melt(
    id_vars=["product"],
    value_vars=["quarter_1", "quarter_2", "quarter_3", "quarter_4"],
    var_name="quarter",
    value_name="sales",
)
"""
df = 
| product     | quarter   | sales |
| ----------- | --------- | ----- |
| Umbrella    | quarter_1 | 417   |
| SleepingBag | quarter_1 | 800   |
| Umbrella    | quarter_2 | 224   |
| SleepingBag | quarter_2 | 936   |
| Umbrella    | quarter_3 | 379   |
| SleepingBag | quarter_3 | 93    |
| Umbrella    | quarter_4 | 611   |
| SleepingBag | quarter_4 | 875   |
"""

说实话melt与pivot还没太搞懂……

多DataFrame处理

连接

有方法pd.concat()，具体参数：

objs 传入待串联的Series/DataFrame的序列（如顺序的列表）
axis 定轴（0->行，1->列）

具体原理如下：

dic = {
    'A':[1,2,3],
    'B':[4,5,6],
    'C':[7,8,9],
}
df1 = pd.DataFrame(dic,index = ['P','Q','R'])
dic_ = {
    'A':[11,12,13],
    'B':[14,15,16],
    'C':[17,18,19],
}
df2 = pd.DataFrame(dic_,index = ['P','Q','R'])
dic__ = {
    'D':[11,12,13],
    'E':[14,15,16],
    'F':[17,18,19],
}
df3 = pd.DataFrame(dic__,index = ['P','Q','R'])
dic___ = {
    'A':[11,12,13,1],
    'B':[14,15,16,1],
    'C':[17,18,19,1],
}
df4 = pd.DataFrame(dic___,index = ['P','Q','R'])


print(pd.concat([df1,df2],axis = 1))
"""
   A  B  C   A   B   C
P  1  4  7  11  14  17
Q  2  5  8  12  15  18
R  3  6  9  13  16  19
"""

print(pd.concat([df1,df2],axis = 0))
"""
    A   B   C
P   1   4   7
Q   2   5   8
R   3   6   9
P  11  14  17
Q  12  15  18
R  13  16  19
"""

#可能存在两个DataFrame列/行名不符的情况，其处理方式如下：

print(pd.concat([df1,df3],axis = 0))
"""
     A    B    C     D     F     G
P  1.0  4.0  7.0   NaN   NaN   NaN
Q  2.0  5.0  8.0   NaN   NaN   NaN
R  3.0  6.0  9.0   NaN   NaN   NaN
P  NaN  NaN  NaN  11.0  14.0  17.0
Q  NaN  NaN  NaN  12.0  15.0  18.0
R  NaN  NaN  NaN  13.0  16.0  19.0
"""

#但不能出现待合并部分尺寸不匹配的情况，会直接报错

积累琐碎内容

获取字符串长度

DF中会有如下使用场景：想要将一个字符串列依次获取每个字符串长度获得一个对应的int新列。对此有方法str.len()。其作用对象是单列（Series），如：

dic = {
    'A':['sad','wet','wet'],
    'B':['wet','wet','wet'],
    'C':['wet','wet','wet'],
}
df1 = pd.DataFrame(dic,index = ['P','Q','R'])
df4=df1['A'].str.len()
"""
df4:
P    3
Q    3
R    3
"""