1. Johngo学长首页
  2. 技术点详细复盘专题
  3. Python

Python Pandas用法整理

• Python • 阅读 41

Pandas简介

Pandas是一-种基于NumPy的开源的数据分析工具包,提供了高
性能、简单易用的数据结构和数据分析函数。Pandas提供 了方便的类
表格和类SQL的操作，同时提供了强大的缺失值处理方法，可以方便的
进行数据导入、选取、清洗、处理、合并、统计分析等操作。

相关函数用法

Pandas中的Series对象是一种带有标签数据的一维数组,标签在Pandas
中有对应的数据类型”Index”， Series类似于一维数组与字典的结合。

（1）创建Series时，可通过index参数指定索引，未指定索
引时,采用默认索引，从0开始，不断递增;

print('不使用索引')
s_1 = pd.Series([1,3,4])
print(s_1)

（2）通过列表、元组创建:索引大小必须和列表大小一致

print('使用索引')
s_2 = pd.Series([2,3,4],index=list("ABC"))
print(s_2)

（3）通过numpy的ndarray创建:必须是一维数组， 且
数组大小和索引大小要一致;

print('使用np,必须是一维数组')
s_3 = pd.Series(np.arange(5))
print(s_3)

（4）通过字典创建:默认索引为字典的关键字,指定索引
时,会以索引为键获取值,没有值时,默认为NaN ;

print('通过字典创建')
s_4 = pd.Series({"C":"d","B":"b"},index=["B","C"])
print(s_4)

（5）通过标量创建:重复填充标量到每个索引上;

print('通过标量创建')
s_5 = pd.Series(8,index=[6,4,8,1])
print(s_5)

（6）获得具体值和索引

s_5 = pd.Series(8,index=[6,4,8,1])
print(s_5)
print('获取具体值')
print(s_5.values)
print('获取具体索引')
print(s_5.index)

Pandas的Index对象可以看作是一个不可变数组, Index对象中可以包含重复
值。可直接通过Pandas中的Index类创建Index对象，也可以通过Series或DataFrame
中的index属性获取对应的Index对象。Index对象可以在多个数据间共享。
（1）创建Index

print('创建索引')
index_1 = pd.Index([1,2,3,4])
print(index_1)

（2）指定Index

print('指定index')
index_1 = pd.Index([1,2,3,4])
s_6 = pd.Series(range(4),index = index_1)
print(s_6)

系统一般会为Series对象默认分配一 个从0开始不断增大的索引 ,称为隐式索引;
用户通过index指定的索引称为显式索引。如果显式索引为整数，容易冲突， 通过键访
问采用的是显式索引,通过切片访问采用的是隐式索引,尽量不要使用整数作为显式
索引。其他情况下,两种方式可以共存。
（1）可以通过索引、切片、布尔表达式访问数据;通过切片访问时,显式索引结果包含最后一个索引隐式索引结果不包含最后一个索引。

s_1 = pd.Series([1,2,3,4,5,6],index=list("ABCDEF"))
print(s_1[2])
print(s_1["A":"D"])
print(s_1[1:4])
print(s_1[s_1 > 2])

（2）loc:显式索引访问,即根据用户指定的索引访问
iloc:隐式索弓|访问,即根据位置序号访问

s_2 = pd.Series(range(2,8),index=range(1,7))
print(s_2.iloc[2])
print(s_2.loc[2])
print(s_2.iloc[2:4])
print(s_2.loc[2:4])

（1）sort_index():对Series按照索引排序，生成一个新的Series对象
（2）sort_values():对Series按照值排序，生成一个新的Series对象
（3）rank():对值进行排名，从1开始，对于相同的值默认采用平均排名
（4）reindex():重新设置索引，生成一个新的Series对象。新的索引长度和原始索引长度可
以不相同，如果新的索引不在原始数据中，则对应的值为NaN，如果在原始数据中，则
值保持不变，可通过method参数指定值填充的方案(要求原始索引是递增的)，还可通
过fill_ value参数指定填充值;

s_1 = pd.Series([8,4,7,3],index=list("ADEC"))
print(s_1)
print(s_1.sort_index())
print(s_1.sort_values())
print(s_1.rank())
print(s_1.reindex(list("ABCDEF")))
print(s_1.reindex(list("ABCDEF"),fill_value=0))

（5）Series对象也可执行numpy中的一些运算,此时只对值进行操作,索引和值之间的对应
关系不变;Series对象之间执行运算时，会自动进行对齐,相同索引之间执行相应运算，不同索引对
应的值为NaN。

s_1 = pd.Series([8,4,7,3],index=list("ADEC"))
print(np.square(s_1))
s_2 = pd.Series([1,2,4],index=list("ABC"))
print(s_1 + s_2)

（6）unique():去除值中重复的数据,即每个值只保留一个;
（7）value_counts():统计各数据出现的次数,并按次数从高到低排序;

s_1 = pd.Series([3,6,8,3,2,6,7,6])
print(s_1.unique())
print(s_1.value_counts())

DataFrame

DataFrame可以看作是-种既有行索引，又有列索引的二维数组,类似于
Excel表或关系型数据库中的二维表,是Pandas中最常用的基本结构。

（1）可通过值为一维ndarray , list, dict或者Series的字典或列表;二维的ndarray
单个Series、 列表、一维数组;其他的DataFrame等创建;

names = ["张三","李四","王五"]
ages = [20,18,19]
d_1 = pd.DataFrame({"姓名":names,"年龄":ages})
print(d_1)
d_2 = pd.DataFrame([names,ages])
print(d_2)
d_4 = pd.DataFrame(np.random.randint(10,30,(3,4)))
print(d_4)

（2）创建DataFrame时,可通过index和columnns参数指定行索引和列索引,若
没有指定索引,则默认为从0开始的连续数字;

names = ["张三","李四","王五"]
ages = [20,18,19]
s_names = pd.Series(names,index=["A","B","C"])
s_ages = pd.Series(ages,index=["B","C","A"])
d_3 = pd.DataFrame({"姓名":s_names,"年龄":s_ages})
print(d_3)

（3）通过多个Series创建DataFrame时，多个Series对象会自动对齐。若指定了
index ，则会丢弃所有未和index匹配的数据。如果指定的索引|不存在,则对应
的值默认为NaN.

s_names = {"A01":"国防科技大学","A03":"中南大学","A05":"湖南大学"}
s_types = {"A05":"双一流B","A01":"军事","A04":"985"}
d_5 = pd.DataFrame({"学校名称":s_names,"学校类型":s_types})
print(d_5)
d_6 = pd.DataFrame({"学校名称":s_names,"学校类型":s_types},index=["A01","A03","A05"])
print(d_6)

DataFrame对象与二维numpy数组和共享索引的若干个Series对象构成的字
典有很多相似之处, DataFrame中数据的访问可与它们进行类比学习。
（1）将DataFrame看成字典

  • 以列的索引为关键字,获取某一列数据 ,例如d_1[列索引] ,结果为Series对象，可进一步
    获取某个数据，例如 d_1[列索引][行索引]，需要使用两个中括号，不能合并;
s_names = pd.Series(["Tom","John","Tony","Jency","Mary"],index=list("ABCDE"))
s_ages = pd.Series([18,20,18,19],index=list("ABDE"))
d_1 = pd.DataFrame({"姓名":s_names,"年龄":s_ages})
print(d_1)
print(d_1["姓名"])
print(d_1["姓名"]["A"])
  • 如果列的索引为字符串，则能够以列名为属性名获取某一列数据 ，例如d_1.属性名，前提是列名符合标识符的命名规范。如果列名不符合规范或与DataFrame中属性相同,例如shape、index等,则不能用属性形式。
s_names = pd.Series(["Tom","John","Tony","Jency","Mary"],index=list("ABCDE"))
s_ages = pd.Series([18,20,18,19],index=list("ABDE"))
d_1 = pd.DataFrame({"姓名":s_names,"年龄":s_ages})
print(d_1.姓名)
print(d_1["姓名"] is d_1.姓名)

（2）看成二维数组

  • 与Series类似，DataFrame中也存在隐式索引和显式索引。显式索引主要是根据 对应的标签访问数据,而隐式索引主要是 根据位置序号访问数据。DataFrame也支持索引器访问数据,其中 loc[行索引,列索引] 通过显示索引访问数据， iloc[行索引,列索引] 通过隐式索引访问数据。\
  • 支持行列转置、布尔表达式等
  • 支持行切片操作,不支持列切片。若想访问多列数据,可将多个列索引放在一个列表中，例如d_1[[列1,列2]]
s_names = pd.Series(["Tom","John","Tony","Jency","Mary"],index=list("ABCDE"))
s_ages = pd.Series([18,20,18,19],index=list("ABDE"))
d_1 = pd.DataFrame({"姓名":s_names,"年龄":s_ages})
print(d_1.T)
print(d_1[d_1.年龄 == 18])
print(d_1[1:3])
print(d_1["A":"D"])
print(d_1[["年龄","姓名"]])
print(d_1.iloc[3,1])
print(d_1.iloc[1:3,0:1])
print(d_1.loc["D","姓名"])
print(d_1.loc[["A","D"],["姓名","年龄"]])
print(d_1.loc["A":"D", "姓名":"年龄"])

属性名作用shape获取形状信息,结果为一个元组dtypes获取各个字段的数据类型，结果为Seriesvalue获取数据内容，结果通常为二维数组columns获取列索引，即字段名称，结果为Indexindex获取行索引，即行的标签，结果为Indexaxis同时获取行索引和列索引，结果为Index列表

示例:

d_1 = pd.DataFrame(np.random.randint(10, 30, (20, 10)),index = [chr(x) for x in range(116, 96,-1)],
                                        columns = [chr(x) for x in range(65, 75)])
print(d_1)
print(d_1.shape)
print(d_1.index)
print(d_1.columns)
print(d_1.axes)
print(d_1.values)
print(d_1.dtypes)

方法名作用info()显示基本信息,包括行列索引信息、每列非空元素数量每列数据的类型,整体所占内存大小等head(n)获取前n行数据, n默认为5 ,结果为DataFrametail(n)获取后n行数据, n默认为5 ,结果为DataFramedescrible()数据的整体描述信息,包括:非空值数量、平均值、标准差、最小值、最大值等,结果为DataFramecount()统计各列中非空值的数量,结果为Seriessample(n,axis)随机从数据中按行或列抽取n行或n列apply(fun,axis)对每一行或每-列元素执行函数applymap(fun)对每一个数据执行函数to_dict()转化为dict类型对象,可指定字典中值的类型,如listto_excel(文件名)对每一行或每一列元素执行函数sort_values(by)根据值进行排序,可以指定一列或多列 ,返回新的对象sort_index()根据值进行排序,可以指定一列或多列 ,返回新的对象rank()对每-列的值进行排名,从小到大,从1开始isnan(),isnull()对每一个元素判断是否为缺失值dropna()删除缺失值,可指定删除行或列、缺失值满足的条件等fillna()用value值填充空值,返回新的对象rename()重命名,通过columns对列索引重命名, index对行索引重命名set_index()设置索引列,可以用一个已有列名作为索引,返回新的对象groupby()对数据进行分组,例如根据某列或多列进行分组d1.append(d2)将d_ 2中的行添加到d_ 1的后面,会自动对齐,没有内容的部分默认为NaNsum(),mean(),max(),min(),median(),std() var()对每列数据求和、求平均数、最大值、最小值中位数、标准差、方差nunique()统计每一列中不重复的元素个数

示例:

d_1 = pd.DataFrame(np.random.randint(10, 30, (20, 10)),index = [chr(x) for x in range(116, 96,-1)],
                                        columns = [chr(x) for x in range(65, 75)])
print(d_1.info())
print(d_1.head(8))
print(d_1.tail())
print(d_1.describe())
print(d_1.count())
print(d_1.sample(5, axis=0))
print(d_1.sample(5, axis=1))
print(d_1.apply(np.sum,axis=1))
print(d_1.applymap(np.square))
print(d_1.to_dict(orient="list"))
print(d_1.to_excel("./file/data.xls"))

print(d_1.sort_values(["C", "D"]) )
print(d_1.sort_index())
print(d_1.rank(method="min") )
print(d_1.rename(index={"o": "00"}))
print(d_1.set_index("C"))
print(d_1.groupby("D").agg("mean"))
d_2 = pd.DataFrame(np.random.randint(50, 80,(5,4)),columns=list("ABCD"), index = list("abxyz"))
print(d_1.append(d_2))

DataFrame中提供了一个join()方法用于将其他DataFrame中的列合并到当前DataFrame中,类似于数据库中的连接,支持内连接、外连接、左连接和右连接等,默认情况采用左连接。默认情况下，根据两个对象的索引进行匹配连接,如果有相同列名,则需指定后缀,也可通过on参数指定关联的列，需将该列作为其他对象的索引。

join(other，on=None，how="left"，lsuffix=" "，rsuffix=" "，sort=False)

上述方法参数表示的含义如下：
on：用于连接名。 //如果两个表中行索引和列索引重叠，那么当使用join()方法进行合并时，使用参数on指定重叠的列名即可
how：可以从{“left”，”right”，” outer”，”inner”} 中任选一个，默认使用left的方式。
lsuffix：接收字符串，用于在左侧重叠的列名后添加后缀名。
rsuffix：接收字符串，用于在右侧重叠的列名后添加后缀名。
sort：接收布尔值，根据连接键对合并的数据进行排序，默认为False。

s_names = pd.Series(["张三","李四","王五","赵六","钱七"],index = list("ADBCE"))
s_ages = pd.Series([18, 20,18,19], index = list("ADBC"))
s_nums = pd.Series(["001","003","006","008"],index = list("ADCE"))
s_names_2 = pd.Series(["张三","李四","孙五","周六"],index = list("ADCE"))
d_1 = pd.DataFrame({"姓名": s_names, "年龄": s_ages})
print(d_1)
d_2 = pd.DataFrame({"姓名":s_names_2, "学号":s_nums})
print(d_2)
print(d_2.set_index("姓名"))
print(d_1.join(d_2,rsuffix = "r"))
print(d_1.join(d_2.set_index("姓名"),on = "姓名"))
print(d_1.join(d_2.set_index("姓名"),on = "姓名",how = "right" ))
print(d_1.join(d_2.set_index("姓名"), on = "姓名",how = "inner") )
print(d_1.join(d_2.set_index("姓名"),on = "姓名",how = "outer"))

DataFrame中常用方法

  • read_excel():从excel文件中读取数据;
  • read_csv():从csv文件中读取数据;
  • read_clipboard() :从剪切板中数据;
  • read_html() :从网页中读取数据;
  • read_ json():从json格式文本中读取数据
  • read_pickle() :从pickle文件中读取数据;

io :文件路径,可以是本地文件也可以是网络文件，支持xls、xIsx、 xlsm等格式;
sheet_ name :表单序号或名称,可以是一个列表,同时读取多个表单,默认为第一个表单;
hearder : 表头,可以是整数或整数列表;
names :指定列名，
index_col :索引列,可以是整数或整数列表;
usecols :使用到的列;
dtype :指定每- -列的数据类型;
skiprows :跳过多少行;
nrows :解析多少行;
na_values :指定哪些值被看做是缺失值;

get_option(属性名) :获取相应的选项值;
set_option(属性名,值) :设置相应的选项值;
reset_option(属性名) :重置相应的选项值;
describe_option(属性名) :获取相应的选项描述信息;
option_context(属性名) :设置临时的选项值;

display.max_rows :显示的最大行数,默认为60行，None表示不限制,显示所有;
display.max_columns :显示的最大列数,默认为0 ,根据宽度自动确定, None表示不限制,显示所有;
display.expand_frame_repr :是否换行打印超过宽度的数据,默认为True ;
display_max_colwidth :显示的最大列宽默认为50个字符,超出以省略号表示，None表示不限制;
display.precision :设置小数显示精度,默认为6位。
示例:

pd.set_option("display.max_rows", None)
pd.set_option("display.max_columns", None)
pd.set_option("display.expand_frame_repr", False)
pd.describe_option("display.expand_frame_repr")
pd.set_option("display.precision", 2)
d_1 = pd.DataFrame(np.random.rand(100,20))
print(d_1)

缺失值是指数据集中的某些值为空。常见的处理方法有:删除法、替换法和插补法。

  • 删除法:直接将包含缺失值的记录删除，常用于缺失值比例非常低,如5%以内;
  • 替换法:用某种值直接替换缺失值,例如连续变量的均值或中位数,离散变量的众数等
  • 插补法:根据其他已观测值进行预测,例如K近邻、回归插补法等;

（1）dropna():删除包含缺失值的行,可通过axis参数设置删除所在列,通过thresh参数指定阈值,只有非空值大于该阈值的行或列才保留
（2）fillna():用指定值填充缺失值,可为不同的列指定不同的填充值,可通过method参数指定填充方式;通过limit参数限定填充的数量;
（3）isna()或isnull() :判断元素是否为缺失值;

使用示例:

s_1 = pd.Series(["aa", "bb","cc","dd", "ee"],index = list("ABCEF"))
s_2 = pd.Series([20, 18,19,20], index=list("ACEG"))
s_3 = pd.Series(["01", "02","03","04","05","06","07"], index=list( "ABCDEFG"))
d_1 = pd.DataFrame({"姓名": s_1, "年龄": s_2,"学号": s_3})
print(d_1)
print("删除包含缺省值的行")
print(d_1.dropna())
print("删除包含缺省值的列")
print(d_1.dropna(axis=1,thresh=5))
print("填充缺省值")
print(d_1.fillna("未知",limit=2))
print(d_1.fillna(method="ffill"))
print(d_1.isnull())

分组( group by )操作主要是根据某个或某些特征对原始数据进行分割,然后可以在子集上应用一些函数。例如聚合、转换、过滤等。 Series 和DataFrame都支持分组操作。分组后将得到一个分组对象,通过groups属性可查看分组信息,通过get_group()可获取某个组详情,通过 agg()可对组执行聚合函数,通过 transform()方法可对组进行转换,通过 filter()方法对某些组进行过滤。

s_names = ["aa","bb", "cc","dd","ee","ff","gg","hh", "mm","nn"]
s_sex = random.choices(["男","女"],k = len(s_names))
s_class = random.choices(["A", "B", "C"], k=len(s_names))
score = random.choices(range(50, 100), k=len(s_names) )
d_1 = pd.DataFrame({"班级": s_class , "姓名": s_names,"性别":s_sex,"成绩": score})
print(d_1)
print("进行分组")
group = d_1.groupby("班级")
print(group.groups)
print("求组内的值")
print(group.agg([np.max,np.min, np.mean]))
print(group.transform(lambda x: x - np.min(x)))
print(group.filter(lambda x: np.mean(x) > 80))
print(d_1.groupby(["班级","性别"]).mean())

实际应用中,常常涉及到数据的合并,例如数据存放在不同文件中。Pandas中提供 了一-些数据
合并的方法,例如merge()、contact()等。

参数：

  • left :左边的数据对象;
  • right :右边的数据对象;
  • how :连接方式,默认为inner ,此外还有left、right、outer等 ;
  • on :连接的列名称,必须在两个对象中,默认以两个对象的列名的交集作为连接键;
  • left_on:左边对象中用于连接的键的列名;
  • right_on:右边对象中用于连接的键的列名;
  • left_index:使用左边的行索引作为连接键
  • right_index:使用右边的行索引作为连接键;
  • sort:是否将合并的数据排序,默认为False ;
  • suffixes :列名相同时,指定的后缀

示例：

s_names = pd.Series(["张三","李四","王五","赵六","钱七"],index=list("ADBCE"))
s_ages = pd.Series([18,20,18,19],index = list("ADBC"))
s_nums = pd.Series(["001","003" ,"006","008"],index = list("ADCE"))
s_names_2 =pd.Series(["张三","李四","孙五","周六"],index = list("ADCE"))
d_1 = pd.DataFrame({"姓名": s_names,"年龄":s_ages})
d_2 = pd.DataFrame({"姓名": s_names_2,"学号": s_nums})
print(d_1)
print(d_2)
print("内连接合并")
print(pd.merge(d_1,d_2))
print("左连接合并")
print(pd.merge(d_1,d_2, how = "left"))
print("右连接合并")
print(pd.merge(d_1, d_2, how = "right" ))
print("外连接合并")
print(pd.merge(d_1, d_2,how = "outer" ))
print(pd.merge(d_1, d_2,left_index = True,right_index = True))

参数：

  • objs :需合并的对象序列;
  • axis :指定合并的轴, 0/ ‘index’，1/ ‘columns’, 默认为0 ;
  • join :连接方式,只有inner和outer ,默认为outer
  • ignore_index :是否忽略索引,默认为False ;
  • verify_integrity:验证完整性,较为耗时,默认为False ;

示例：

s_names = pd.Series(["张三", "李四", "王五", "赵六", "钱七"], index=list("ADBCE"))
s_ages = pd.Series([18, 20, 18, 19], index=list("ADBC"))
s_nums = pd.Series(["001", "003", "006", "008"], index=list("ADCE"))
s_names_2 = pd.Series(["张三", "李四", "孙五", "周六"], index=list("ADCE"))
d_1 = pd.DataFrame({"姓名": s_names, "年龄": s_ages})
d_2 = pd.DataFrame({"姓名": s_names_2, "学号": s_nums})
print(d_1)
print(d_2)
print("outer拼接")
print(pd.concat([d_1, d_2]))
print("inner拼接")
print(pd.concat([d_1,d_2], join="inner"))
print("指定合并的轴")
print(pd.concat([d_1, d_2], axis=1))
print(pd.concat([d_1, d_2], axis=1, join="inner"))

Original: https://blog.csdn.net/qq_41234663/article/details/127240208
Author: lzl2040
Title: Python Pandas用法整理

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/741972/

转载文章受原作者版权保护。转载请注明原作者出处！

赞 (0)
0

【自取】最近整理的，有需要可以领取学习：



Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言 刷题答案下载！

大家都在看

亲爱的 Coder【最近整理，可免费获取】👉 最新必读书单  | 👏 面试题下载  | 🌎 免费的AI知识星球