Pandas的学习和使用一
一、介绍
Pandas 包是 Python 的核心数据分析库，提供了快速、灵活、明确的数据结构。
Pandas 的目标是成为 Python 数据分析实践与实战的必备高级工具，其长远目标是成为最强大、最灵活、可以支持任何语言的开源数据分析工具。
Pandas 适用于处理以下类型的数据：
1、与 SQL 或 Excel 表类似的表格数据;
2、有序和无序数据;
3、带行列标签的矩阵数据;
4、任意其它形式的观测、统计数据集;等
Pandas 的主要数据结构是 Series（一维数据）与 DataFrame（二维数据），这两种数据结构足以处理金融、统计、社会科学、工程等领域里的大多数典型用例
提示：Pandas 已广泛应用于金融领域
官方文档：http://pandas.pydata.org/pandas-docs/stable/
安装：pip install pandas==2.2.1
二、Pandas数据结构
2.1、Series的使用（一维数据）
Series：一维数组,与Numpy中的一维array类似。它是一种类似于一维数组的对象，是由一组数据(各种 NumPy 数据类型)以及一组与之相关的数据标签(即索引)组成。
仅由一组数据也可产生简单的 Series 对象，用值列表生成 Series 时，Pandas 默认自动生成整数索引 。
使用列表创建：
Pandas中两个重要的属性values和index,values是Series对象的原始数据，index对应了Series对象的索引对象。
属性values和index
data.values
data.index
指定index
data=pd.Series([5,4,6,3,1],index=['one','two','three','four','five'])
使用list列表指定index
data=pd.Series([4,3,2,1],index=list('abcd'))
传入字典创建，默认将key作为index
population_dict={'sh':2800,'bj':3000,'gz':1500,'sz':1200}
population_series=pd.Series(population_dict)
如果既用了字典创建了Series对象，又显示的指定了index，如果key不存在，则值为NaN
#如果存在取交集
sub_series=pd.Series(population_dict,index=['bj','sh'])
#如果不存在则值为NaN
sub_series=pd.Series(population_dict,index=['bj','xa'])
将一个标量与index对象一起传入创建
data=pd.Series(10,index=list('abcd'))
2.2、DataFrame的使用（二维数据）
DataFrame 是 Pandas 中的一个表格型的数据结构，包含有多列的数据，每列可以是不同的值类型(数值、字符串、布尔型等)，DataFrame 即有行索引也有列索引，可以被看做是由 Series 组成的字典。
将两个series对象作为dict的value传入，就可以创建一个DataFrame对象。
# 创建DataFrame
population_dict={'beijing':3000,'shanghai':1200,'guangzhou':1800}
area_dict={'beijing':300,'shanghai':180,'guangzhou':200}
population_series=pd.Series(population_dict)
area_series=pd.Series(area_dict)
citys=pd.DataFrame({'area':area_series,'population':population_series})
# 列表创建
population_dict={'beijing':3000,'shanghai':1200,'guangzhou':1800}
area_dict={'beijing':300,'shanghai':180,'guangzhou':200}
data=pd.DataFrame([population_dict,area_dict])
#添加index属性
data=pd.DataFrame([population_dict,area_dict],index=['population','area'])
print(data)
索引columns的使用
二维数组指定columns和index创建
import numpy as np
pd.DataFrame(np.random.randint(0,10,(3,2)),columns=list('ab'),index=list('efg'))
2.3、Excel文件
使用read_excel()方法导入文件，首先要指定文件的路径。
说明：
使用Pandas模块操作Excel时候，需要安装openpyxl
pip install openpyxl==3.1.2
import pandas as pd
pd.read_excel('stu_data.xlsx')
#【示例】导入.xlsx文件时，指定导入哪个Sheet
pd.read_excel('stu_data.xlsx',sheet_name='Target')
pd.read_excel('stu_data.xlsx',sheet_name=0)
#【示例】导入.xlsx文件时，通过index_col指定行索引
pd.read_excel('stu_data.xlsx',sheet_name=0,index_col=0)
#【示例】导入.xlsx文件时，通过header指定列索引
pd.read_excel('stu_data.xlsx',sheet_name=0,header=1)
pd.read_excel('stu_data.xlsx',sheet_name=0,header=None)
有时候本地文件的列数太多，而我们又不需要那么多列时，我们就可以通过设置usecols参数来指定要导入的列。
#【示例】导入.xlsx文件时，通过usecols指定导入列
pd.read_excel('stu_data.xlsx',usecols=[1,2,3])
df1 = pd.read_excel('./stu_data.xlsx')
# df1
# 通过pandas设置显示的最大行数
pd.set_option('display.max_rows',10)
# df1
# 读取excel文件，获取指定列
df2 = pd.read_excel('./stu_data.xlsx',usecols=[0,1,3])
# df2
# 读取excel文件，指定索引列
df3 = pd.read_excel('./stu_data.xlsx',index_col=0) # 默认值是0
# df3
# 读取excel文件，指定标题行
# header默认值是0，表示第一行是标题行，header=1，表示第二行是标题行
# header=None表示未选择标题行，默认从0开始计算
df4 = pd.read_excel('./stu_data.xlsx',header=1)
# df4
# 读取excel文件，指定工作簿
# sheet_name可以指定工作簿的名称，也可以是工作簿的索引
df5 = pd.read_excel('./stu_data.xlsx',sheet_name='Target')
df5
2.4、CSV文件
导入csv文件时除了指明文件路径，还需要设置编码格式。
在国内，Python中用得比较多的两种编码格式是UTF-8和gbk，默认编码格式是UTF-8。
我们要根据导入文件本身的编码格式进行设置，通过设置参数encoding来设置导入的编码格式。
#【示例】导入.csv文件，文件编码格式是gbk
pd.read_csv('stu_data.csv',encoding='gbk')
2.5、Txt文件
导入.txt文件用得方法时read_table()，read_table()是将利用分隔符分开的文件导入。DataFrame的通用函数。它不仅仅可以导入.txt文件，还可以导入.csv文件。
#【示例】导入.txt文件
pd.read_table('test_data.txt',encoding='utf-8',sep='\t')
#【示例】导入.csv文件，指明分隔符
pd.read_table('stu_data.csv',encoding='gbk',sep=',')
2.6、数据库数据
# 配置 MySQL 连接引擎
conn = pymysql.connect(
host = 'localhost',
user = 'root',
passwd = 'root',
db = 'mydb',
port=3306,
charset = 'utf8'
)
# 读取数据表
pd.read_sql(
sql :需要执行的 SQL 语句/要读入的表名称
con : 连接引擎名称
index_col = None :将被用作索引的列名称
columns = None :当提供表名称时，需要读入的列名称 list
)
tab1 = pd.read_sql('SELECT * FROM t_menus',con=conn)
tab1 = pd.read_sql('SELECT count(1) FROM t_menus',con=conn)
number = 10
tab1 = pd.read_sql(
f'SELECT * FROM t_menus LIMIT {number}',
con=conn,
index_col = ['empno'],
)
# 数据sql
CREATE TABLE `t_menus` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) NOT NULL,
`path` varchar(32) DEFAULT NULL,
`level` int(11) DEFAULT NULL,
`pid` int(11) DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `name` (`name`),
KEY `pid` (`pid`),
CONSTRAINT `t_menus_ibfk_1` FOREIGN KEY (`pid`) REFERENCES `t_menus` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=52 DEFAULT CHARSET=utf8mb4;
INSERT INTO `t_menus` VALUES (-1,'全部',NULL,0,NULL),(1,'用户管理',NULL,1,-1),(2,'权限管理',NULL,1,-1),(3,'商品管理',NULL,1,-1),(4,'订单管理',NULL,1,-1),(5,'数据统计',NULL,1,-1),(11,'用户列表','/user_list',2,1),(21,'角色列表','/author_list',2,2),(22,'权限列表','/role_list',2,2),(31,'商品列表','/product_list',2,3),(32,'分类列表','/group_list',2,3),(33,'属性列表','/attribute_list',2,3),(41,'订单列表','/order_list',2,4),(51,'统计列表','/data_list',2,5);
2.7、保存数据–外部文件
df.to_csv(
filepath_or_buffer :要保存的文件路径
sep =：分隔符
columns :需要导出的变量列表
header = True :指定导出数据的新变量名，可直接提供 list
index = True :是否导出索引
mode = 'w' : Python 写模式,读写方式：r,r+ , w , w+ , a , a+
encoding = 'utf-8' :默认导出的文件编码格式
)
df2.to_csv('temp.csv')
#===========================
df.to_excel(
filepath_or_buffer :要读入的文件路径
sheet_name = 1|Sheet :要保存的表单名称
)
df2.to_excel('temp.xlsx', index = False, sheet_name = data)
2.8、保存数据–数据库
df.to_sql(
name :将要存储数据的表名称
con : 连接引擎名称
if_exists = 'fail' :指定表已经存在时的处理方式
fail :不做任何处理(不插入新数据)
replace :删除原表并重建新表
append :在原表后插入新数据
index = True :是否导出索引 )
from sqlalchemy import create_engine
con = create_engine('mysql+pymysql://root:root@localhost:3306/mydb?charset=utf8')
df.to_sql('t_stu',con,if_exists=append)
注意:
需要安装sqlalchemy:pip install sqlalchemy==2.0.16
三、快速了解数据
head()与 tail()
当数据表中包含了数据行数过多时，而我们又想看一下每一列数据都是什么样的数据时，就可以把数据表中前几行或后几行数据显示出来进行查看；head()方法返回前 n 行(观察索引值)，显示元素的数量默认是 5，但可以传递自定义数值；tail()方法返回后 n 行(观察索引值)，显示元素的数量默认是 5，但可以传递自定义数值；
代码如下：
#浏览前几条记录
df.head()
df.head(10)
#浏览最后几条记录
df.tail()
info()
熟悉数据的第一点就是看下数据的类型，不同的数据类型的分析思路是不一样的，比如说：数值类型的数据就可以求均值，但是字符类型的数据就没法求均值了。info()方法查看数据表中的数据类型，而且不需要一列一列的查看，info()可以输出整个表 中所有列的数据类型。
shape
熟悉数据的第二点就是看下数据表的大小，即数据表有多少行，多少列 。shape()方法会以元组的形式返回行、列数。注意 shape 方法获取行数和列数时不会把索引和列索引计算在内。
describe()
熟悉数据的第三点就是掌握数值的分布情况，即均值是多少，最值是多少，方差及分位数分别是多少 。describe()方法就是可以就可以获取所有数值类型字段的分布值。
3.1、列操作
修改变量列 筛选变量列 删除变量列 添加变量列
操作列的变量 columns
df.columns = 新的名称list
df.columns
操作列的方法：rename()重命名
# 通过rename修改列的名称，列的数量可以不一致，但是必须要对应的列，默认不会修改源数据
# 如果需要修改源数据，需要设置inplace=True
df.rename(columns={'学号1':'学号','身高1':'身高','体重1':'体重'},inplace=True)
根据返回的不同数据类型，设置传入列表标题方式不同
df.学号 # 单列
df['学号'] # 单列
df[['学号','性别']] # 多列
增加列：df[‘列名’] = 数据
drop()删除列
df.drop(
columns = [‘要删除列名’]
inplace = False:是否直接替换原数据
)
# 修改原列数据，如果需要修改原数据，需要传入参数，inplace=True df.drop(columns=['体重','支出'], inplace=True)
增加列 df[‘列名’] = value
# 值为一个标量
df['new_col1'] = 1
df.newvar = 1 #注意该命令不会报错!但并没有添加新变量
# 值为一个列表,那么列表的长度必须和行数一致
df['new_col2']= range(0,52)
# 值为一个Series,那么Series的长度可以不与行数一致，但是超出行数值会被设置为NaN
df['new_col3'] = pd.Series([1,2,3,4,5,6])
# 值为一个表达式，是原用的列上的值进行计算
df['new_col4'] = df['身高'] + 1
# 值为map处理的值，是原用的列上的值进行计算
df['new_gender'] = df['性别'].map({'男':1,'女':0})
# 值为一个函数
import math
df['new_col5'] = math.sqrt(9)
df['new_col5'] = math.sqrt(df.体重) #报错
通过函数计算变量的值
df.apply(func,axis)
func : 希望对行/列执行的函数表达式
axis = 0 :针对行还是列逬行计算
0 ’ index’ : 针对每列进行计算
1 ‘columns’: 针对每行逬行计算
def get_value(data):
return data['体重']
df['a'] = df.apply(get_value, axis=1)
df.head()
另一种写法
df [‘列名’] = df. oldvar. apply(函数表达式)
df['n5'] = df.体重.apply(math.sqrt)
df['n7'] = df.体重.apply(numpy.sqrt)
# 使用自定义函数
def get_first(tmp):
return tmp[:1]
df['n6'] = df.开设.apply(get_first)
在指定位置插入新变量列：df.insert(loc,column,value,allow_duplicates)
loc :插入位置的索引值，0 <= loc <= len (columns)
column :插入的新列名称
value : Series 或者类数组结构的变量值
allow_duplicates = False :是否允许新列重名
# 指定位置增加新列
df.insert(1,'new_col',100)
df.insert(1,'new_col2',df.课程.apply(get_first))
# 生成新的df
df.assign(varname = expression)
# 返回新的dataframe
df2 = df.assign(n8 = df.课程.apply(get_first))
3.2、数据类型转换–基本使用
Pandas 支持的数据类型
具体类型是 Python, Numpy 各种类型的混合，可以比下表分的更细
1、float 小数
2、int 整数
3、bool 布尔值
4、datetime64 日期和时间的数据类型
5、timedelta 时间差的数据类型。它表示两个日期或时间之间的差异，可以用于执行日期和时间的加减操作
6、category 分类变量。是具有有限数量的取值的变量，通常用于表示诸如状态、类别、标签等离散的值
7、object 通用的数据类型，用于表示存储在 DataFrame 列中的非数值数据
df.dtypes :査看各列的数据类型
df.dtypes
在不同数据类型间转换
df.astype( )
1、dtype:指定希望转换的数据类型，可以使用 numpy 或者 python 中的数据类型:int/float/bool/str
2、copy = True :是否生成新的副本,而不是替换原数据
3、errors = ‘raise’ : 转换出错时是否抛出错误，raise/ ignore
#将df里所有的列转换成str
df.astype('str')
df.astype('str').dtypes
#修改某一列数据的数据类型
df.column.astype ('str')
#转换错误
df.astype('int', errors = 'ignore').dtypes 明确指定转换类型的函数：
旧版本方法：
1、pd.to_datetime ()
2、pd.to_timedelta ()
3、pd.to_numeric ()
4、df.to_string()
可以通过 df. apply() 来批量逬行多列的转换
pd. to_numeric (df .cloumn)
#转换单列
pd.to_numeric(df.软件)
#选择多列进行转换
df [['cloumn1','cloumn2']].astype('str').apply(pd.to_numeric).dtypes
3.3、建立索引
索引（Index）是用于标识和访问 DataFrame 或 Series 中数据的标签
索引可以看作是数据的标识符或行号，它提供了数据的唯一标识和定位方式
索引不仅提供了数据的定位和访问方式，还支持数据的排序、筛选、分组、重塑等操作
通过合理使用索引，可以提高数据操作和分析的效率和灵活性
建立索引的方式
1、新建数据时建立索引
2、读入数据时建立索引
3、后续指定某列为索引列
新建数据框时建立索引
所有的数据框默认都已经使用从 0 开始的自然数索引，因此这里的"建立”索引指的是自定义索引
df = pd.DataFrame({
'varl' : 1.0,
'var2' : [1,2,3,4],
'var3' : ['test', 'python','test', 'hello'] ,
'var4' : 'cons'
},
index = [0,1,2,3]
)
df
读入数据时建立索引 使用列名或者列号指定为索引，复合索引
使用现有的列：df = pd.read_csv (“filename”, index_col="column”)
使用复合列：df = pd.read_csv (“filename”, index_col=[0,1…])
3.4、设置索引
指定某列为索引列
df.set_index(
keys :被指定为索引的列名，复合索引用 list:格式提供
drop = True :建立索引后是否删除该列
append = False :是否在原索引基础上添加索引，默认是直接替换原索引
inplace = False :是否直接修改原数据框
)
df_new = df.set_index (keys=['学号'，'性别'],drop = False)
df_new = df.set_index (keys='学号', append=True, drop=False)
3.5、还原索引列
df.reset_index(
drop = False :是否将原索引直接删除，而不是还原为变量列
inplace = False :是否直接修改原数据框
)
df.set_index(['col1','col2','col3'])
将索引全部还原为变量：df.reset_index()
是否删除 index 列：df.reset_index(drop=True)
3.6、索引类型
索引类型
Pandas提供了几种常见的索引类型，每种类型都有其特定的特性和用途，以下是一些常见的索引类型：
1、整数索引（Integer Index）
2、标签索引（Label Index）
3、多级索引（Multi-level Index）
4、时间索引（Datetime Index）
df.index
3.7、索引修改
修改索引名
本质上和变量列名的修改方式相同
df = pd.DataFrame({
'name':['zs','ls','ww'],
'level':['vip1','vip2','pm']
})
df.index.name='sno'
df2 = pd.read_excel('stu_data.xlsx')
df3 = df2.set_index(keys = '学号')
df4 = pd.read_excel('stu_data.xlsx')
df5 = df2.set_index(keys = ['学号','性别'])
# df5.index.names = ['no','sex']
df5.index.names=[None,None]
df5
修改索引值
这里的修改本质上是全部替换：df1.index = [‘a’, ‘b’, ‘c’]
3.8、更新索引
在Pandas中，提供reindex方法，可以作用在DataFrame或Series。功能是：
1、添加索引
2、删除现在索引
3、对数据进行重新排序
4、调整DataFrame或Series的索引顺序
方法：
df.reindex()
labels :类数组结构的数值,可选
copy = True :建立新对象而不是直接更改原 DataFrame/Series
method = None :针对已经排序过的索引，确定数据单元格无数据时的填充方法
None :不填补空白
pad/ffill :用前面的有效数值填充
backfill/bfill :用后面的有效数值填充
nearest :使用最接近的数值逬行填充
fill_value :将缺失值用什么数值替代
import pandas as pd
df = pd.DataFrame({
'name':['zs','ls','ww'],
'level':['vip1','vip2','pm']
})
df.reindex([0,1,3])
df.reindex([0,1,2,3],method='ffill')
df.reindex([0,1,2,3],fill_value="test")
Pandas中_reindex_可以使用数据框中不存在的数值建立索引，并据此扩充新索引值对应的索引行/ 列，同时进行缺失值填充操作。
四、Series数据获取
Series选择行数据，方式有多种方式：
索引
单行数据选择
切片
通过行索引进行切片
使用series[start_row:end_row],start_row 是起始行索引，end_row 是结束行索引（不包含在切片中）
loc
通过 索引名称 进行访问和操作数据
使用 df.loc[row_indexer, col_indexer]，其中 row_indexer 是行的标签或布尔条件，col_indexer 是列的标签或布尔条件
iloc
通过整数位置进行访问和操作数据
使用 df.iloc[row_indexer, col_indexer]，其中 row_indexer 是行的整数位置，col_indexer 是列的整数位置
import pandas as pd
data=pd.Series([4,3,25,2,3],index=list('abcde'))
data['a'] #根据key获取，对象[索引名]
data[1] #索引获取，索引位置默认从0开始
data[-1]
import pandas as pd
data=pd.Series([4,3,25,2,3],index=list('abcde'))
data['a':'d'] # 对象[索引名1:索引名2] 前后都包含
data[2:4] #索引切片 对象[索引位置1:索引位置2] 前包含，后不包含
data[-3:-1]
data[data>3] # 筛选条件，对象[条件] 返回符号条件的数据
import pandas as pd
data=pd.Series([4,3,25,2,3],index=list('abcde'))
data.loc['a'] # 通过索引名获取数据
data.loc['a':'c']
import pandas as pd
data=pd.Series([5,3,2,5,9],index=list('abcde'))
data.iloc[1]# 通过索引位置获取数据
五、DataFrame数据获取
df[]的使用
获取单列数据
df[‘列名’]
获取多列数据
df[[‘列名1’,‘列名2’]]
获取多行数据
df[开始索引位置 : 结束索引位置]
df[开始索引名称 : 结束索引名称]
数据筛选
df[条件]
loc的使用
loc[行名称开始:行名称结尾,列名称开始:列名称结尾]
提示:任意一个参数可以省略，开始省略表示从头开始，结尾省略表示到结尾;
loc[行名称,列名称]
loc[[行名称1,行名称2],[列名称1,列名称2]]
iloc的使用
iloc[行号开始:行号结尾,列号开始:列号结尾]
提示:任意一个参数可以省略，开始省略表示从头开始，结尾省略表示到结尾;
iloc[行号,列号]
iloc[[行号1,行号2],[列号1,列号2]]
# loc与iloc获取
import numpy as np
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]},index=list('abc'))
#获取行为'b'的行
data.loc['b']
#使用iloc获取，行为'b'的行，行号为1
data.iloc[1]
# 获取'A'列所有行
data.loc[:,'A']
data.iloc[:,0]
# 获取部分行部分列
#获取abc行，A B列
data.loc[['a','b','c'],['A','B']]
data.iloc[[0,1,2],[0,1]]
# 获取满足条件的行
df[df["支出"]>10]
df[(df["支出"]>10) & (df["性别"]=='女')]
六、isin方法的使用
在Pandas中，isin方法用于检查DataFrame或Series中的元素是否属于指定的值或可迭代对象
它返回一个布尔类型的对象，表示每个元素是否匹配指定的值
# 语法
# df.isin(values)
#values 为序列：对应每个具体值
# values 为字典：对应各个变量名称
# values 为数据框：同时对应数值和变量名称
df.col.isin([1,3,5])
df[ df.col.isin([1,3,5])]
df[ df.index.isin(['val1','val2'])]
df.isin(df2)
df2 = pd.DataFrame({'A':[1,2,3,4,5,6],'B':[1,3,5,7,9,11],'C':[2,4,6,8,10,12]})
# df2
df2[['A','B']].isin([2,9])
筛选数据：
注：按列进行匹配，即df2的A列与values的A列进行匹配，df2的C列与values的C列进行匹配，依次匹配。
七、query方法的使用
在Pandas中，query方法用于根据条件表达式从DataFrame中筛选行。它提供了一种简洁的语法来执行基于字符串的查询操作，类似于SQL中的WHERE子句.
语法
df.query(expr,inplace)
1、expr：语句表达式
2、inplace=False;是否直接替换原数据框
注意:
1、可以使用前缀“@”引用环境变量
2、等号为==，而不是=
df.query("col>10 and col<90 and col1=val")
limit = 5
df.query("col<=@limit & col==val")
df.query("col<=@limit & col!=val")
# 初始化数据
df = pd.read_excel('./stu_data.xlsx')
# df.head()
# 筛选身高大于170的数据
# df[df['身高'] > 170]
# df.query('身高>170')
# query筛选多个数据
# df[(df['身高'] > 170) & (df['性别'] == '女')]
# df.query('身高>170 & 支出>10')
# 获取单个数据
# df.query('43')
# query传递变量
height = 170
df.query('身高 > @height')
八、数据排序
1、索引
用索引排序
在Pandas中，sort_index方法用于对DataFrame或Series按照索引进行排序。它可以按照索引的升序或降序对数据进行重新排序。
df.sort_index(level,ascending,inplace,na_position)
1、level :（多重索引时）指定用于排序的级别顺序号/名称
2、ascending = True :是否为升序排列，多列时以表形式提供
3、inplace = False :
4、na_position = ‘last’ :缺失值的排列顺序
first
last
import pandas as pd
df = pd.DataFrame({'A': [3, 1, 4, 2]}, index=['b', 'd', 'c', 'a'])
# 按照索引的升序排序
sorted_df = df.sort_index()
print(sorted_df)
# 输出:
# A
# a 2
# b 3
# c 4
# d 1
# 按照索引的降序排序
sorted_df = df.sort_index(ascending=False)
print(sorted_df)
# 输出:
# A
# d 1
# c 4
# b 3
# a 2
import pandas as pd
s = pd.Series([3, 1, 4, 2], index=['b', 'd', 'c', 'a'])
# 按照索引的升序排序
sorted_s = s.sort_index()
print(sorted_s)
# 输出:
# a 2
# b 3
# c 4
# d 1
# dtype: int64
# 按照索引的降序排序
sorted_s = s.sort_index(ascending=False)
print(sorted_s)
# 输出:
# d 1
# c 4
# b 3
# a 2
# dtype: int64
2、数据值
使用变量值排序
在Pandas中，可以使用sort_values方法对DataFrame或Series进行排序。sort_values方法可以按照指定的列或多列的值进行升序或降序排序
df.sort_values(by,ascending,inplace,na_position)
by :指定用于排序的变量名，多列时以列表形式提供
ascending = True :是否为升序排列
inplace = False :是否直接替换原数据框
na_position = 'last‘ :缺失值的排列顺序
first
last
import pandas as pd
df = pd.DataFrame({'A': [3, 1, 4, 2], 'B': [9, 5, 7, 6]})
# 按照单列的值进行升序排序
sorted_df = df.sort_values('A')
print(sorted_df)
# 输出:
# A B
# 1 1 5
# 3 2 6
# 0 3 9
# 2 4 7
# 按照多列的值进行排序，先按'A'列进行升序排序，再按'B'列进行降序排序
sorted_df = df.sort_values(['A', 'B'], ascending=[True, False])
print(sorted_df)
# 输出:
# A B
# 1 1 5
# 3 2 6
# 0 3 9
# 2 4 7
import pandas as pd
s = pd.Series([3, 1, 4, 2])
# 按照值进行升序排序
sorted_s = s.sort_values()
print(sorted_s)
# 输出:
# 1 1
# 3 2
# 0 3
# 2 4
# dtype: int64
# 按照索引进行降序排序
sorted_s = s.sort_values(ascending=False)
print(sorted_s)
# 输出:
# 2 4
# 0 3
# 3 2
# 1 1
# dtype: int64
九、修改数据值
本质上是如何直接指定单元格的问题，只要能准确定位单元地址，就能够做到准确替换。
# 判断哪一行是我们要的数据
df.体重[1] = 78
df['体重'][1] = 68
df.loc[1,'体重'] = 78
df.开设.isin(['不清楚'])
df.开设[df.开设.isin(['不清楚'])] = '可以'
对应数值的替换
df.replace(to_replace,value,inplace)
1、to_replace = None : 将被替换的原数值，所有匹配的值将被用 value 替换
类型 str/regex/list/dict/Series/numeric/None
2、value = None :希望填充的新数值
3、inplace = False
df.开设.replace('可以','不清楚',inplace = True)
df.性别.replace(['女','男'],[0,1],inplace = True)
df.性别.replace({0:'女',1:'男'},inplace = True)
批量修改值
指定数值范围的替换
方法一：使用正则表达式完成替换
df.replace(regex, newvalue)
方法二：使用行筛选方式完成替换
用行筛选方式得到行索引，然后用 loc 命令定位替换
目前也支持直接筛选出单元格进行数值替换
注意：
query 命令的类 SQL 语句可以逬行检索，但不直接支持数值替换
# 使用正则匹配数据
df.开设.replace(regex = '不.+',value = '可以',inplace = True)
#iloc loc
df.支出.iloc[0:3] = 20
df.支出.loc[0:2] =30
#条件筛选替换
df.体重[df.体重>70] =70
df[df.体重==70].体重 = 80 # 注意引用问题
#query()的使用
df.query('性别 == "女" and 体重 > 60 ').体重 = 50
df.loc[df.query('性别 == "女" and 体重 > 60 ').体重.index,'体重'] = 50
409
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
