Pandas基础操作

于 2025-04-04 04:23:47 发布
阅读量2k 收藏 38
点赞数 50
文章标签： pandas
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_86300041/article/details/146829164
版权

Pandas基础操作

一,Pandas的定义

概述:

Python在数据处理上独步天下：代码灵活、开发快速；尤其是Python的Pandas包，无论是在数据分析领域、还是大数据
开发场景中都具有显著的优势.

Pandas的优势:

  • Pandas是Python的一个第三方包，也是商业和工程领域最流行的结构化数据工具集，用于数据清洗、处理以及分析
  • Pandas在数据处理上具有独特的优势：
    • 底层是基于Numpy构建的，所以运行速度特别的快
    • 有专门的处理缺失数据的API
    • 强大而灵活的分组、聚合、转换功能

适用场景:

  • 数据量大到Excel严重卡顿，且又都是单机数据的时候，我们使用Pandas.
  • Pandas用于处理单机数据(小数据集(相对于大数据来说)).
  • 在大数据ETL数据仓库中，对数据进行清洗及处理的环节使用Pandas.

二, Pandas数据结构和数据类型

图解 在这里插入图片描述

Pandas中有两大核心对象, 分别是: DataFrame和Series, 其中, Series -> 单列数据, DataFrame -> 多列数据

Series对象入门

(1)Series对象定义
概述:

Series是Pandas中的最基本的数据结构对象，下文中简称s对象；是DataFrame的列对象，series本身也具有索引。

Series是一种类似于一维数组的对象，由下面两个部分组成：

  • values：一组数据(numpy.ndarray类型).
  • index：相关的数据索引标签.如果没有为数据指定索引,会自动创建一个0到N-1(N为数据的长度)的整数型索引.
图解:

在这里插入图片描述

(2)创建Series对象.
创建方法
  • 方法一: 通过list列表来创建.
  • 方法二: 使用使用字典或元组创建series对象.
  • 方法三: 使用numpy创建series对象.
案例
案例需求

演示Series对象的创建

实现思路
  1. 导包.
  2. 创建Series对象(s1), 采用: 默认自增索引.
  3. 打印s1.
  4. 创建Series对象(s2), 采用: 自定义索引.
  5. 打印s2.
  6. 使用字典, 元组创建Series对象.
  7. 元组形式.
  8. 打印s3.
  9. 字典形式.
  10. 打印s4 .
  11. 使用numpy创建series对象.
  12. 打印s5.
# 1. 导包.
import pandas as pd
import numpy as np

# 2. 创建Series对象(s1), 采用: 默认自增索引.
s1 = pd.Series([1, 2, 3, 4, 5])
# 3. 打印s1.
print(s1)
# 4. 创建Series对象(s2), 采用: 自定义索引.
s2 = pd.Series([1, 2, 3, 4, 5], index = ['a', 'b', 'c', 'd', 'e'])
# 5. 打印s2.
print(s2)
# 6. 使用字典, 元组创建Series对象.

# 7. 元组形式.
s3 = pd.Series((11, 22, 33, 44, 55))
# 8. 打印s3.
print(s3)
# 9. 字典形式.
s4 = pd.Series({'a': 1, 'b': 3, 'c': 5})
# 10. 打印s4.
print(s4)
# 11. 使用numpy创建series对象.
s5 = pd.Series(np.arange(5))
# 12. 打印s5.
print(s5)
结果图解

在这里插入图片描述

(3)Series对象的属性
Series对象的属性:
  1. Series对象的索引列(的值): Series对象.index
  2. Series对象的值列(的值): Series对象.values
  3. Series对象 根据 索引列(的值) 获取 值列(的值): Series对象[索引列(的值)]
  4. Series对象 根据 索引列(的值) 修改 值列(的值): Series对象[索引列(的值)] = 新的值列(的值)
案例
案例需求

演示Series对象的属性

实现思路
  1. 导包.
  2. 创建Series对象, 索引为: A-F, 值为: 0-5
  3. 加入列表推导式.
  4. 获取Series对象的 索引列(的值).
  5. 获取Series对象的 值列(的值).
  6. Series支持根据 索引列(的值) 获取 值列(的值), 即: Series对象[索引值].
  7. Series对象 根据 索引列(的值) 修改 值列(的值): Series对象[索引列(的值)] = 新的值列(的值).
# 1. 导包.
import pandas as pd
inport numpy as np
# 2. 创建Series对象, 索引为: A-F, 值为: 0-5.
# s6 = pd.Series(data = [0, 1, 2, 3, 4, 5], index = ['A', 'B', 'C', 'D', 'E', 'F'])

# 3. 加入列表推导式.
s6 = pd.Series(data = [i for i in range(6)], index = [i for i in 'ABCDE'])
print(s6)
# 4. 获取Series对象的 索引列(的值).
print(s6.index)		# Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype = 'object')(字符串)
# 5. 获取Series对象的 值列(的值).
print(s6.values)	# [0 1 2 3 4 5]
# 6. Series支持根据 索引列(的值) 获取 值列(的值), 即: Series对象[索引值].
print(s6['D'])		# 3
# 7. Series对象 根据 索引列(的值) 修改 值列(的值): Series对象[索引列(的值)] = 新的值列(的值).
s6['D'] = 99
print(s6)

在这里插入图片描述

DataFrame对象入门

(1)DataFrame对象定义
概述:

DataFrame是一个类似于二维数组或表格（如excel)的对象，既有行索引，又有列索引.

  • 行索引，表明不同行，横向索引，叫index，0轴，axis=0
  • 列索引，表名不同列，纵向索引，叫columns，1轴，axis=1
图解:

在这里插入图片描述

(2)创建DataFrame对象
创建方法
  • 方法一: 通过 字典 + 列表 的方式实现.
  • 方法二: 通过 列表 + 元组 的方式实现.
  • 方法三: 通过 numpy的 ndarray 对象转化为pandas的 DataFrame 对象的方式实现.
(3)案例1
案例需求

演示DataFrame对象的创建

实现思路
  1. 导包.
  2. 场景1: 通过 字典 + 列表 , 并使用默认自增索引的方式实现.
  3. 准备数据集, 每个键值对 = 1列数据.
  4. 把上述的数据集, 封装成DataFrame对象(df1).
  5. 打印(df1)结果.
  6. 场景2: 通过 列表 + 元组 , 并使用自定义索引的方式实现.
  7. 准备数据集, 每一个元组 = 1行数据.
  8. 把上述的数据集和自定义索引, 封装成DataFrame对象(df2).
  9. 打印(df2)结果.
  10. 场景3: 通过 numpy的ndarray 对象转化为pandas的 DataFrame 对象的方式实现.
  11. 创建 numpy的 ndarray对象(arr3).
  12. 打印(arr3)结果.
  13. 把上述的ndarray对象, 封装成DataFrame对象(df3).
  14. 打印(df3)结果.
# 1. 导包.
import pandas as pd
import numpy as np

# 2. 场景1: 通过 字典 + 列表 , 并使用默认自增索引的方式实现.
# 3. 准备数据集, 每个键值对 = 1列数据.
info = {
	'name': ['水冷哥', '深情哥', '紫琪', '德华'],
	'gender': ['女', '男', '保密', '保密'],
	'age': [81, 80, 66, 55]
}
# 4. 把上述的数据集, 封装成DataFrame对象(df1).
df1 = pd.DataFrame(data = info)
# 5. 打印(df1)结果.
df1
# 6. 场景2: 通过 列表 + 元组 , 并使用自定义索引的方式实现.
# 7. 准备数据集, 每一个元组 = 1行数据.
info = [
	('刘亦菲', '女', 39), 
	('迪丽热巴', '女', 31),
	('王志奇', '未知', 66)
]
# 8. 把上述的数据集和自定义索引, 封装成DataFrame对象(df2).
df2 = pd.DataFrame(
	data = info,
	columns = ['姓名', '性别', '年龄'],
	index = ['人物1', '人物2', '人物3']	# 手动指定索引
)
# 9. 打印(df2)结果.
df2
# 10. 场景3: 通过 numpy的ndarray 对象转化为pandas的 DataFrame 对象,并使用自定义索引的方式实现.
# 11. 创建 numpy的 ndarray对象(arr3).
arr3 = np.array(12).reshape(3, 4)
# 12. 打印(arr3)结果.
arr1
# 13. 把上述的ndarray对象, 封装成DataFrame对象(df3).
df3 = pd.DataFrame(
	data = arr3,
	columns = ['a', 'b', 'c', 'd']
)
# 14. 打印(df3)结果.
df3
结果图解

在这里插入图片描述

案例2:DataFrame简单案例 -> 学生信息处理
案例需求

生成10名学生5门功课的成绩的学生信息表

实现思路
  1. 导包.
  2. 生成10名学生, 5门功课的成绩, 成绩范围: 40 ~ 100.
  3. 方法1.
  4. 修改DataFrame对象的 列名 和 索引数值.
  5. 将修改DataFrame对象的 列名 和 索引数值传给DataFrame对象.
  6. 方法2.
  7. rename函数也可以(一个一个值修改).
  8. 方法3.
  9. 修改DataFrame对象的 列名 和 索引数值.
  10. rename函数 + 循环遍历DataFrame对象的 列名 和 索引数值.
  11. 打印修改后的结果.
# 1. 导包.
import pandas as pd
import numpy as np

# 2. 生成10名学生, 5门功课的成绩, 成绩范围: 40 ~ 100.
score_df = pd.DataFrame(np.random.randint(40, 101, (10, 5)))	# 10行, 5列		包左不包右
score_df
# 3. 方法1
# 4. 修改DataFrame对象的 列名 和 索引数值.
# column_names = ['语文', '数学', '英语', '政治', '体育']
# index_names = ['同学0', '同学1', '同学2', '同学3', '同学4', '同学5', '同学6', '同学7', '同学8', '同学9']
# index_names= ['同学' + str(i) for i in range(score_df.shape[0])]

# 5. 将修改DataFrame对象的 列名 和 索引数值传给DataFrame对象.
# score_df.columns = column_names
# score_df.index = index_names

# 6. 方法2.
# 7. rename函数也可以(一个一个值修改).
# score_df.name(index = {0: '同学0', 1: '同学1', ...}, columns = {0: 'AI课程', 1: '大数据课程'...}, inplace = True)

# 8. 方法3.
# 9. 修改DataFrame对象的 列名 和 索引数值.
column_names = ['语文', '数学', '英语', '政治', '体育']
# index_names = ['同学0', '同学1', '同学2', '同学3', '同学4', '同学5', '同学6', '同学7', '同学8', '同学9']
index_names= ['同学' + str(i) for i in range(score_df.shape[0])]

# 10. rename函数 + 循环遍历DataFrame对象的 列名 和 索引数值.
score_df.rename(
# 				i 的值: 0 ~ 9.			
	index = {i: index_names[i] for i in range(score_df.shape[0])},
#				i 的值: 0 ~ 4.
	columns = {i: colunm_names[i] for i in range(score_df.shape[1])},
	inplace = True
)
# 11. 打印修改后的结果.
score_df
结果图解

在这里插入图片描述

(3)DataFrame对象的属性
DataFrame对象的属性:
  1. DataFrame对象的索引列(的值): DataFrame对象.index
  2. DataFrame对象的数据(的值): DataFrame对象.values
  3. DataFrame对象的列名(的值): DataFrame对象.columns
  4. DataFrame对象的维度(的值): DataFrame对象.shape
  5. DataFrame对象的行列转置: DataFrame对象.T
案例
案例需求

演示DataFrame对象的属性

实现思路
  1. 导包.
  2. 创建DataFrame对象.
  3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
  4. 修改DataFrame对象的 列名 和 索引数值.索引为: A-F, 列为: G-K
  5. 获取DataFrame对象的 索引列(的值).
  6. 获取DataFrame对象的 列名(的值).
  7. 获取DataFrame对象的 数据(的值).
  8. 获取DataFrame对象的 维度(的值).
  9. 获取DataFrame对象的 行列转置.
# 1. 导包.
import pandas as pd
import numpy as np
# 2. 创建DataFrame对象.
# 3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
df = pd.DataFrame(np.random.randint(0, 31, (6, 5)))	# 6列, 5行		包左不包右
# 4. 修改DataFrame对象的 列名 和 索引数值.索引为: A-F, 列为: G-K
df.index = ['A', 'B', 'C', 'D', 'E', 'F']
df.columns = ['G', 'H', 'I', 'J', 'K']
# 5. 获取DataFrame对象的 索引列(的值).
print(df.index)			# Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')
# 6. 获取DataFrame对象的 列名(的值).
print(df.columns)		# Index(['G', 'H', 'I', 'J', 'K'], dtype='object')
# 7. 获取DataFrame对象的 数据(的值).
print(df.values)		
# 8. 获取DataFrame对象的 维度(的值).
print(df.shape)			# (6, 5)

# 9.  获取DataFrame对象的 行列转置.
print(df.T)
结果图解

在这里插入图片描述

DataFrame的基本函数
基本函数的常见操作
编号函数作用
1head(n)查看前n行的数据(默认是5行)
2tail(n)查看后5行的数据(默认是5行)
3info()查看df对象的详细信息
4describe()查看df对象的 描述性 统计信息
5reset_index(drop = True)重置索引
6set_index()重新设置索引
案例
案例需求

演示DataFrame的基本函数的常见操作

实现思路
  1. 导包.
  2. 创建DataFrame对象(df).
  3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
  4. 修改DataFrame对象的 列名 和 索引数值.索引为: A-F, 列为: G-K.
  5. 查看df对象.
  6. 查看前5行数据.
  7. 查看前3行数据.
  8. 查看后5行数据.
  9. 查看后3行数据.
  10. 查看df对象的详细信息.
  11. 查看df对象的 描述性 统计信息.
  12. 重置列索引.
  13. 重新设置列索引.
# 1. 导包.
import pandas as pa
import numpy as np

# 2. 创建DataFrame对象(df).
# 3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
df = pd.DataFrame(np.random.randint(0, 31,(6, 5)))		# 6列, 5行		包左不包右
# 4. 修改DataFrame对象的 列名 和 索引数值.索引为: A-F, 列为: G-K.
df.index = ['A', 'B', 'C', 'D', 'E', 'F']
df.columns = ['G', 'H', 'I', 'J', 'K']
# 5. 查看df对象.
df
# 6. 查看前5行数据.
df.head()
# 7. 查看前3行数据.
df.head(3)
# 8. 查看后5行数据.
df.tail()
# 9. 查看后3行数据.
df.tail(3)
# 10. 查看df对象的详细信息.
df.info()
# 11. 查看df对象的 描述性 统计信息.
df.describle()
# 12. 重置列索引.
df.reset_index(drop = False)	# drop = False, 默认值, 不是删除原索引列, 将原索引列转移到第一列
df.reset_index(drop = True)		# drop = True, 删除原索引列
# 13. 重新设置列索引.
# df.set_index('G')				# 'G'充当索引列
# 'J', 'K'充当索引列.
df.set_index('J', 'K')
结果图解

在这里插入图片描述
在这里插入图片描述

三, Pandas的数据类型

Pandas的数据类型介绍

编号数据类型说明对应的Python类型
1object字符串类型string
2int整数类型int
3float浮点数类型float
4datetime日期时间类型datetime包中的datetime类型
5timedelta时间差类型datetime包中的timedelta类型
6category分类类型无原生类型, 可以自定义
7bool布尔类型bool (True, False)
8nan空值类型None

案例

案例需求

演示Pandas的数据类型

实现思路
案例1: 演示 object类型, int类型, float类型, bool类型, nan类型
  1. 导包.
  2. 创建DataFrame对象(df1).
  3. 查看df1对象.
  4. 查看df1对象的详细信息.
# 1. 导包
import pandas as pd
import numpy as np

# 2. 创建DataFrame对象(df1).
df1 = pd.DataFrame({
    'number': [1, 2, 3, 4],
    'name': [np.NaN, '深情哥', '紫琪', '德华'],
    'gender': ['女', np.NAN, '保密', np.nan],
    'age': [81.1, 80.2, 33.3, 55],
    'Marriage': [False, False, True, False]
})

# 3. 查看df1对象.
df1
# 4. 查看df1对象的详细信息.
df1.info()
结果图解

在这里插入图片描述

案例2: 演示 datetime类型
  1. 导包.
  2. 创建DataFrame对象(df2).
  3. 查看df2对象.
  4. 查看df2对象的详细信息.
# 1. 导包.
import pandas as pd
import numpy as np

# 2. 创建DataFrame对象(df2).
df2 = pd.DataFrame(['2025-03-29', '2025-03-30', '2025-03-31'], dtype = 'datatime64[ns]')
# 3. 查看df2对象.
df2
# 4. 查看df2对象的详细信息.
df2.info()
结果图解

在这里插入图片描述

案例3: 演示 timedelta类型
  1. 导包.
  2. 设置起始日期.
  3. 设置结束日期.
  4. 打印结果
  5. 打印类型
# 1. 导包.
import pandas as pd
# 2. 设置起始日期.
start_date = pd.to_datetime('2004-08-21')
# 3. 设置结束日期.
end_date = pd.to_datetime('2025-03-29')
# 4. 打印结果.
print(end_date - start_date)					# 7525 days 00:00:00
# 5. 打印类型.
print(type(end_date - start_date))				# <class 'pandas._libs.tslibs.timedeltas.Timedelta'>
案例4: 演示 category类型
  1. 导包.
  2. 创建一个category类型的Series(s1).
  3. 查看s1.
  4. 打印s1的类型.
  5. 打印s1元素的元素.
# 1. 导包.
import pandas as pd
# 2. 创建一个category类型的Series(s1).
s1 = pd.Series(['男', '女', '保密'], dtype = 'category')
# 3. 查看s1.
s1
# 4. 打印s1的类型.
print(type(s1))									# <class 'pandas.core.series.Series'>
# 5. 打印s1元素的元素.
print(s1.dtypes)								# category
结果图解

在这里插入图片描述

四, Pandas的基本操作

数据加载

数据加载的定义
概述

Pandas在使用中需要读取数据, 因此需要加载数据操作.

格式
DataFrame对象 = pd.read_文件格式(r'绝对路径', encoding = '文件对应编码表')
案例
案例需求

读取文件中的数据, 并进行查看.

实现思路
  1. 导包.
  2. 加载数据.
  3. 查看数据.
  4. 查看详细信息.
  5. 查看描述性统计信息.
# 1. 导包.
import pandas as pd
# 2. 加载数据.
df = = pd.read_文件格式(r'绝对路径', encoding = '文件对应编码表')
# 3. 查看数据.
df
# 4. 查看详细信息.
df.info()
# 5. 查看描述性统计信息.
df.describe()

索引操作

索引操作的定义
概述:

Pandas可以根据行列索引获取信息, 进行查看

格式:
# 格式1: 根据行列索引获取元素, (先列后行).
DataFrame对象['列名']['行索引']
# 格式2: 结合 loc 根据: 行索引 和 列名 来获取元素.
DataFrame对象.loc[行索引, 列名] # 获取单个元素
 DataFrame对象.loc[起始行索引:结束行索引, [列名1, 列名2, ...]] # 获取多个元素
# 格式3: 结合 iloc 根据: 行号 和 列号 来获取元素
DataFrame对象.iloc[行号, 列号] # 获取单个元素
DataFrame对象.iloc[起始行号:结束行号, 起始列号:结束列号] # 获取多个元素
案例
案例需求

根据行列索引获取信息, 进行查看

实现思路
  1. 导包.
  2. 创建创建DataFrame对象(df).
  3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
  4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为: G-K.
  5. 格式1: 根据行列索引获取元素, (先列后行).
  6. DataFrame对象[‘列名’][‘行索引’]
  7. 尝试使用: 先行后列.
  8. 格式2: 结合 loc 根据: 行索引 和 列名 来获取元素.
  9. DataFrame对象.loc[行索引, 列名] # 获取单个元素.
  10. DataFrame对象.loc[起始行索引:结束行索引, [列名1, 列名2, …]] # 获取多个元素.
  11. 格式3: 结合 iloc 根据: 行号 和 列号 来获取元素
  12. DataFrame对象.iloc[行号, 列号] # 获取单个元素
  13. DataFrame对象.iloc[起始行号:结束行号, 起始列号:结束列号] # 获取多个元素
# 1. 导包.
import pandas as pd
import numpy as np
# 2. 创建DataFrame对象(df).
# 3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
df = pd.DataFrame(np.random.randint(0, 31, (6, 5)))	# 6列, 5行		包左不包右
# 4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为: G-K.
df.index = ['A', 'B', 'C', 'D', 'E', 'F']
df.columns = ['G', 'H', 'I', 'J', 'K']
# 5. 格式1: 根据行列索引获取元素, (先列后行).
# 6. DataFrame对象['列名']['行索引']
df['G']['A']								# 20
# 7. 尝试使用: 先行后列.
# df['A']['G']		# 错误写法
# 8. 格式2: 结合 loc 根据: 行索引 和 列名 来获取元素.
# 9. DataFrame对象.loc[行索引, 列名] # 获取单个元素.
df.loc['A', 'G']							# 20
# 10. DataFrame对象.loc[起始行索引:结束行索引, [列名1, 列名2, ...]] # 获取多个元素
df.loc['A':'F', ['G', 'K']]
# 11. 格式3: 结合 iloc 根据: 行号 和 列号 来获取元素.
# 12. DataFrame对象.iloc[行号, 列号] # 获取单个元素.
df.iloc[0, 0]								# 20
# 13. DataFrame对象.iloc[起始行号:结束行号, 起始列号:结束列号] # 获取多个元素
df.iloc[0:5, 0:4]
结果图解

在这里插入图片描述

赋值操作

赋值操作的定义
概述

Panads中可以通过赋值操作改变列的值

格式
格式1:
df['列名'] = 要新赋的值
格式2:
df.列名 = 要新赋的值
案例
案例需求

通过赋值操作改变列的值

实现思路
  1. 导包.
  2. 创建DataFrame对象(df).
  3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
  4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为: G-K.
  5. 查看数据.
  6. 赋值操作.
  7. 格式1: df[‘列名’] = 要新赋的值.
  8. 格式2: df.列名 = 要新赋的值.
  9. 查看结果.
# 1. 导包.
import pandas as pd
import numpy as np
# 2. 创建DataFrame对象(df).
# 3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
df = pd.DataFrame(np.random.randint(0, 31, (6, 5)))	# 6列, 5行		包左不包右
# 4. 修改DataFrame对象(df1)的 列名 和 索引数值.索引为: A-F, 列为:  G-K.
df.index = ['A', 'B', 'C', 'D', 'E', 'F']
df.columns = ['G', 'H', 'I', 'J', 'K']
# 5. 查看数据.
df
# 6. 赋值操作.
# 7. 格式1: df['列名'] = 要新赋的值.
df['G'] = 23
# 8. 格式2: df.列名 = 要新赋的值.
df.K = 1
# 9. 查看结果.
df2 = df
df2
结果图解

在这里插入图片描述

排序操作

排序操作的定义
概述:

Pandas中排序有两种形式，一种对于索引进行排序，一种对于内容进行排序.

格式:
# 格式1: 基于1列的数据进行排序.
DataFrame对象.sort_values(by = '列名', ascending = True)	# 升序(默认升序)
DataFrame对象.sort_values(by = '列名', ascending = False)	# 降序
# 格式2: 基于列1的数据进行排序在列1的数据相同的情况下, 基于 列2的数据进行排序.
DataFrame对象.sort_values(by = ['列名1', '列名2', ...], ascending = [False, True, ...])
# 格式3: 基于索引进行排序.
DataFrame对象.sort_index(ascending = True)		# 默认升序.
# 格式4: Series对象也有 sort_index(), sort_values() 排序方法.
DataFrame对象.列名.sort_index(ascending = True)		# 索引升序		这里'DataFrame对象.列名'相当于'Series对象'
DataFrame对象.列名.sort_values(ascending = False)	# 数据降序
案例
案例需求

对数据按照需求进行排列

实现思路
  1. 导包.
  2. 创建DataFrame对象(df).
  3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
  4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为: G-K.
  5. 基于G列做 升序, 降序 排列.
  6. 基于G列降序排列, G列的数据一样, 基于I列降序排列.
  7. 基于索引排序.
  8. Series对象也有 sort_index(), sort_values() 排序方法.
  9. 将G列基于索引升序排列.
    10.将G列基于数据降序排列.
# 1. 导包.
import pandas as pd
import numpy as np
# 2. 创建DataFrame对象(df).
# 3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
df = pd.DataFrame(np.random.randint(0, 31, (6, 5)))	# 6列, 5行		包左不包右
# 4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为:  G-K.
df.index = ['A', 'B', 'C', 'D', 'E', 'F']
df.columns = ['G', 'H', 'I', 'J', 'K']
# 5. 基于G列做 升序, 降序 排列.
df.sort_values(by = 'G', ascending = True)		# 升序
df.sort_values(by = 'G', ascending = False)		# 降序
# 6. 基于G列降序排列, G列的数据一样, 基于I列降序排列.
df.sort_valies(by = ['G', 'I'], ascending = [False, False])
# 7. 基于索引排序.
df.sort_index(ascending = True)		# 默认升序
# 8. Series对象也有 sort_index(), sort_values() 排序方法.
# 9. 将G列基于索引升序排列.
df.G.sort_index(ascending = True)		# 索引升序			这里'DataFrame对象.列名'相当于'Series对象'
# 10.将G列基于数据降序排列.
df.G.sort_values(ascending = False)	# 价格降序			这里'DataFrame对象.列名'相当于'Series对象'
结果图解

在这里插入图片描述
在这里插入图片描述

五, DataFrame的运算

算数运算

算术运算符
  • 加: ‘+’
  • 减: ‘-’
算术运算的格式
# 1. 加法运算	列值(数据) + n
# 格式1:    
DataFrame对象.列名.add(n)		# 这里'DataFrame对象.列名'相当于'Series对象'
# 格式2:
DataFrame对象.列名.add(n)		# 这里'DataFrame对象.列名'相当于'Series对象'
# 2. 减法运算	列值 - n
# 格式1:		列值(的数据) - n
DataFrame对象.列名.sub(n)		# 这里'DataFrame对象.列名'相当于'Series对象'
# 格式2:
DataFrame对象.列名 - n			# 这里'DataFrame对象.列名'相当于'Series对象'
案例
案例需求

算数运算的演示

实现思路
  1. 导包.
  2. 创建DataFrame对象(df).
  3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
  4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为: G-K.
  5. G列名(的数据) + 3
  6. 格式1: DataFrame对象.列名.add(n) # 这里’DataFrame对象.列名’相当于’Series对象’
  7. 格式2: DataFrame对象.列名.add(n) # 这里’DataFrame对象.列名’相当于’Series对象’
  8. I列名(的数据) - 3
  9. 格式1:DataFrame对象.列名.sub(n) # 这里’DataFrame对象.列名’相当于’Series对象’
  10. 格式2: DataFrame对象.列名 - n # 这里’DataFrame对象.列名’相当于’Series对象’
# 1. 导包.
import pandas as pd 
import numpy as np
# 2. 创建DataFrame对象(df).
# 3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
df = pd.DataFrame(np.random.randint(0, 31, (6, 5)))		# 6列, 5行		包左不包右
# 4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为:  G-K.
df.index = ['A', 'B', 'C', 'D', 'E', 'F']
df.columns = ['G', 'H', 'I', 'J', 'K']
# 5. G列名(的数据) + 3
# 6. 格式1: DataFrame对象.列名.add(n)		# 这里'DataFrame对象.列名'相当于'Series对象'
df.G.add(3)
# 7. 格式2: DataFrame对象.列名 + n		# 这里'DataFrame对象.列名'相当于'Series对象'
df.G + n
# 8. I列名(的数据) - 3
# 9.  格式1:DataFrame对象.列名.sub(n)		# 这里'DataFrame对象.列名'相当于'Series对象'
df.G.sub(3)
# 10. 格式2: DataFrame对象.列名 - n			# 这里'DataFrame对象.列名'相当于'Series对象'
df.G - 3
结果图解

在这里插入图片描述

逻辑运算

逻辑运算符
  • 与: ‘&’
  • 或: ‘|’
逻辑运算的格式
# 1. '与'逻辑运算, 筛选范围数据 
# 格式1:
DataFrame对象[(DataFrame对象.列名 > n1) & (DataFrame对象.列名 < n2)]		# 细节: 多组判断记得加 小括号.
# 格式2:
DataFrame对象[(DataFrame对象['列名'] > n1) & (DataFrame对象['列名'] < n2)]	# 标准写法.
# 格式3:	使用query()函数.
DataFrame对象.query('列名 > n1 & 列名 < n2')								# query()函数优化写法
 
# 2. '或'逻辑运算, 筛选固定数据
# 格式1:
 DataFrame对象[(DataFrame对象.列名 == n1) | (DataFrame对象.列名 == n2)]
# 格式2:  	使用isin()函数.
DataFrame对象[DataFrame对象.列名.isin([n1,n2])]
案例
案例需求

演示逻辑运算

实现思路
  1. 导包.
  2. 创建DataFrame对象(df).
  3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
  4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为: G-K.
  5. 完成需求.
  6. 需求1: 筛选出 G列中 大于 5 的数据.
  7. 需求2: 筛选出 G列中 大于 5 , 且 小于 20 的数据.
  8. 格式1:
  9. DataFrame对象[(DataFrame对象.列名 > n1) & (DataFrame对象.列名 < n2)] # 细节: 多组判断记得加 小括号.
  10. 格式2:
  11. DataFrame对象[(DataFrame对象[‘列名’] > n1) & (DataFrame对象[‘列名’] < n2)] # 标准写法.
  12. 格式3: 使用 query() 函数
  13. DataFrame对象.query(‘列名 > n1 & 列名 < n2’) # query()函数优化写法
  14. 需求3: 查询 G的数据为 的一行的所有数据.
  15. 格式1:
  16. DataFrame对象[(DataFrame对象.G == n1| (DataFrame对象.G == n2)]
  17. 格式2: 使用 isin() 函数
  18. DataFrame对象[DataFrame对象.G,isin([, ])]
  19. 格式3:
  20. DataFrame对象.query(‘列名 == n1 | 列名 == n2’)
  21. 格式4:
  22. DataFrame对象.query(‘G in [n1, n2]’)
# 1. 导包.
import pandas as pd
import numpy as np
# 2. 创建DataFrame对象(df).
# 3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
df = pd.DataFrame(np.random.randint(0, 31, (6, 5)))		# 6列, 5行		包左不包右
# 4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为:  G-K.
df.index = ['A', 'B', 'C', 'D', 'E', 'F']
df.columns = ['G', 'H', 'I', 'J', 'K']
# 5. 完成需求.
# 6. 需求1: 筛选出 G列中 大于 5 的数据.
df[df.G > 5]
# 7. 需求2: 筛选出 G列中 大于 5 , 且 小于 20 的数据.
# 8. 格式1:
# 9. DataFrame对象[(DataFrame对象.列名 > n1) & (DataFrame对象.列名 < n2)]		# 细节: 多组判断记得加 小括号.
df[(df.G > 5) & (df.G < 20)]
# 10. 格式2:
# 11. DataFrame对象[(DataFrame对象['列名'] > n1) & (DataFrame对象['列名'] < n2)]	# 标准写法.
df[(df['G'] > 5) & (df['G'] < 20)]
# 12. 格式3:		使用 query() 函数.
# 13. DataFrame对象.query('列名 > n1 & 列名 < n2')								# query()函数优化写法
df.query('G > 5 & G < 20')
# 14. 需求3: 查询 G的数据为 的一行的所有数据.
# 15. 格式1:
# 16. DataFrame对象[(DataFrame对象.G == n1| (DataFrame对象.G == n2)]
df[(df.G == 24| df.G == 25)]
# 17. 格式2:		使用 isin() 函数
# 18. DataFrame对象[DataFrame对象.G.isin([n1, n2])]
df[df.G.isin([24, 25])]  
# 19. 格式3:
# 20. DataFrame对象.query('列名 == n1 | 列名 == n2')
df.query('G ==24 | G == 25')
# 21. 格式4:
# 22. DataFrame对象.query('G in [n1, n2]')
df.query('G in [24, 25]')
结果图解

在这里插入图片描述

统计运算

统计函数
统计函数及其操作
编号函数作用
1describe()查看各列的描述性的 统计信息(个数, 最大值, 最小值, 平均值, 中位数, 25%分位数, 75%分位数).
2count()用于求非空 (或非NaN) 元素的数量. (axis = 0时, 针对列计算, axis = 1时, 针对行计算)(默认axis = 0)
3sum()用于求和
4mean()用于求平均值
5median()用于求中位数.
6min()用于求最小值.
7max()用于求最大值
8mode()用于求众数
9abs()用于求绝对值
10prod()用于求乘积
11std()用于求标准差
12var()用于求均方差
13idxmax()用于返回最大值的行索引
14idxmin()用于返回最小值的行索引
案例
案例需求

演示统计函数及其操作

实现思路
  1. 导包.
  2. 创建DataFrame对象(df).
  3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
  4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为: G-K.
  5. 完成需求.
  6. 需求1:查看描述性统计信息.
  7. 需求2: 分别求出A行和I列的元素的数量
  8. 需求3: 对所有列求和.
  9. 需求4:对所有列求平均值
  10. 需求5: 对J列求平均值.
  11. 需求6: 对所有列求中位数.
  12. 需求7: 对所有列求最小值.
  13. 需求8: 对所有列求最大值.
  14. 需求9: 对所有列求众数
  15. 需求10: 对G列求绝对值.
  16. 需求11: 求所有列的所有数据的乘积.
  17. 需求12: 对所有列求标准差.
  18. 需求13: 对所有列求方差.
  19. 需求14: 返回所有列的最大值的行索引.
  20. 需求15: 返回所有行的最大值的列索引.
  21. 需求16: 返回所有列的最小值的行索引.
  22. 需求17: 返回所有行的最小值的列索引.
# 1. 导包.
import pandas as pd
import numpy as np
# 2. 创建DataFrame对象(df).
# 3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
df = pd.DataFrame(np.random.randint(0, 31, (6, 5)))				# 6列, 5行		包左不包右
# 4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为:  G-K.
df.index = ['A', 'B', 'C', 'D', 'E', 'F']
df.columns = ['G', 'H', 'I', 'J', 'K']
# 5. 完成需求.
# 6. 需求1:查看描述性统计信息.
df.describe()
# 7. 需求2: 分别求出所有行和所有列的元素的数量
df.A.count(axis = 1)
af.I.count()
# 8. 需求3: 对所有列求和.
df.sum()
# 9. 需求4:对所有列求平均值.
df.mean()
# 10. 需求5: 对J列求平均值.
df.J.mean()						# 9.166666666666666
# 11. 需求6: 对所有列求中位数.
df.median()
# 12. 需求7: 对所有列求最小值.
df.min()
# 13. 需求8: 对所有列求最大值.
df.max()
# 14. 需求9: 对所有列求众数.
df.mode()
# 15. 需求10: 对G列求绝对值.
df.G.abs()
# 16. 需求11: 求所有列的所有数据的乘积.
df.prod()
# 17. 需求12: 对所有列求标准差.
df.std()
# 18. 需求13: 对所有列求方差.
df.var()
# 19. 需求14: 返回所有列的最大值的行索引.
df.idxmax()
# 20. 需求16: 返回所有列的最小值的行索引.
df.idxmin()
结果图解

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

累计统计函数
累计统计函数及其操作
编号函数作用
1cumsum()计算前1/2/3/…/n个数的和
2cummax()计算前1/2/3/…/n个数的最大值
3cummin()计算前1/2/3/…/n个数的最小值
4cumprod()计算前1/2/3/…/n个数的积
案例
案例需求

演示统计函数及其操作

实现思路
  1. 导包.
  2. 创建DataFrame对象(df).
  3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
  4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为: G-K.
  5. 完成需求.
  6. 需求1: 对所有列的数据进行累加操作.
  7. 需求2: 对G列的数据进行取最大值操作.
  8. 需求3: 对所有列的数据进行取最小值操作.
  9. 需求4: 对I列的数据进行累乘操作.
# 1. 导包
import pandas as pa
import nimpu as np
# 2. 创建DataFrame对象(df).
# 3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
df = pd.DataFrame(np.random.randint(0, 31, (6, 5)))			# 6列, 5行		包左不包右
# 4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为:  G-K.
df.index = ['A', 'B', 'C', 'D', 'E', 'F']
df.columns = ['G', 'H', 'I', 'J', 'K']
# 5. 完成需求.
# 6. 需求1: 对所有列的数据进行累加操作.
df.cumsum()
# 7. 需求2: 对G列的数据进行取最大值操作.
df.G.cummax()
# 8. 需求3: 对所有列的数据进行取最小值操作.
df.cummin()
# 9. 需求4: 对I列的数据进行累乘操作.
df.I.cumprod()
结果图解

在这里插入图片描述

apply()函数自定义运算

apply()函数的定义
背景:

上述的函数都是Pandas定义好逻辑的, 有时需要传入一些自定义的逻辑,就需要用到 apply()函数了.

概述:

apply()函数可以自定义逻辑

格式:
# 格式:
df.apply(func, axis = 0)

(1) func: 自定义函数
(2) axis: axis = 0 默认为列进行计算; axis = 1 为行进行计算.

案例
案例需求

同时获取到 多列的 最大值 和 最小值 的差值.

实现思路
  1. 导包.
  2. 创建DataFrame对象(df).
  3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
  4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为: G-K.
  5. 思路1: 分解版.
  6. 自定义函数 my_func, 接收 某列的数据, 计算该列的最大值和最小值, 返回差值.
  7. 获取到 H列 和 I列.
  8. 方法1:
  9. 方法2:
  10. 方法3:
  11. 方法4:
  12. 通过apply()函数, 调用上述的自定义函数, 作用到 指定的列.
  13. 思路2: 合并版, 通过 lambda函数实现.
# 1. 导包.
import pandas as pd
import numpy as np
# 2. 创建DataFrame对象(df).	
# 3. 准备数据集(随机生成30个在0 ~ 30之间的数, 维度为(6, 5)6行5列).
df = pd.DataFrame(np.random.randint(0, 31, (6, 5)))		    # 6列, 5行		包左不包右
# 4. 修改DataFrame对象(df)的 列名 和 索引数值.索引为: A-F, 列为:  G-K.
df.index = ['A', 'B', 'C', 'D', 'E', 'F']
df.columns = ['G', 'H', 'I', 'J', 'K']
# 5. 思路1: 分解版.
# 6. 自定义函数 my_func, 接收 某列的数据, 计算该列的最大值和最小值, 返回差值.
def my_func(col):
	return col.max() - col.min()
	
# 7. 获取到 H列 和 I列.
# 8. 方法1:
df[['H', 'I']]
# 9. 方法2:
df.loc[:, ['H', 'I']]
# 10. 方法3:
df.iloc[:, [1, 2]]
# 11. 方法4:
df.iloc[:, 1:3:1]
# 12. 通过apply()函数, 调用上述的自定义函数, 作用到 指定的列.
df[['H', 'I']].apply(my_func, axis = 1)		# axis = 1, 表示对 行 进行操作.
df[['H', 'I']].apply(my_func, axis = 0)		# axis = 0, 表示对 列 进行操作.
df[['H', 'I']].apply(my_func)				# 效果同上, 默认是axis = 0, 	底层 -> 把df的各列分别传入函数, 计算结果.
# 13. 思路2: 合并版, 通过 lambda 函数实现.
df[['H', 'I']].apply(lambda col: col.max() - col.min())
结果图解

在这里插入图片描述

六, 总结

  • Q1:Pandas中的两大核心对象?
    • 分别是: DataFrame和Series
      • Series -> 单列数据
      • DataFrame -> 多列数据
  • Q2: Series对象的定义?
    • Series是一种类似于一维数组的对象，由下面两个部分组成：
      • values：一组数据(numpy.ndarray类型).
      • index：相关的数据索引标签.如果没有为数据指定索引,会自动创建一个0到N-1(N为数据的长度)的整数型索引.
  • Q3: DataFrame对象的定义?
    • DataFrame是一个类似于二维数组或表格（如excel)的对象，既有行索引，又有列索引.
      • 行索引，表明不同行，横向索引，叫index，0轴，axis=0
      • 列索引，表名不同列，纵向索引，叫columns，1轴，axis=1
  • Q4: FataFrame对象的基本函数?
    1. head(n): 查看前n行的数据(默认是5行)
    2. tail(n): 查看后5行的数据(默认是5行)
    3. info(): 查看df对象的详细信息
    4. describe(): 查看df对象的 描述性 统计信息
    5. reset_index(drop = True): 重置索引
    6. set_index(): 重新设置索引
  • Q5: Pandas的数据类型?
    1. object:字符串类型
    2. int: 整数类型
    3. float: 浮点数类型
    4. datetime: 日期时间类型
    5. timedelta: 时间差类型
    6. category: 分类类型
    7. bool: 布尔类型
    8. nan: 空值类型
  • Q6: Pandas的基本操作?
    • 数据加载
    • 索引操作
    • 赋值操作
    • 排序操作
  • Q7: DataFrame的运算?
    • 算数运算
    • 逻辑运算
    • 统计运算
    • apply()函数自定义运算
烈焰猩猩
关注
pandas 基本使用
Ayhan_huang的博客
10-30 1万+
介绍是什么pandas是一个强大的Python数据分析的工具包，它是基于NumPy构建的。关于NumPy，参考这里。主要功能 具备对其功能的数据结构DataFrame、Series 集成时间序列功能 提供丰富的数学运算和操作 灵活处理缺失数据 安装pip install pandas引用pip install pandasSeriesSeries是一种类似于一维数组的对象，由一组数据和一组与之相关的
pandas介绍——基础操作（9）
王伟健的博客
07-10 613
大家好，这次继续python另外一个包的学习~pandas1.pandas Series操作首先让我们重新在jupyter notebook中导入各种包import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns这里简单提一下，matplotlib和seaborn两个包都是我...
pandas基础操作
qq_45011164的博客
10-06 2801
Series 1.Series的创建 1.由列表或numpy数组创建 2.由字典创建 2.Series的常用属性以及常用方法 1.Series的常用属性 2.Series的常用方法 2.DataFrame 1.DataFrame的创建 1.ndarray创建 2.字典创建 2.DataFrame的属性 3.DataFrame的索引和切片操作 1.DataFrame的索引操作 2.DataFrame的切片操作 3.DataFrame的算术运算 4.时间数据类型的转换
Pandas基本操作教程
qq_43283527的博客
09-29 1万+
导入数据 df= pd.read_csv( #该参数是数据在电脑里的路径，可以不填 filepath_or_buffer = r&quot;c:\Users\win 10\Desktop\sz000002.csv&quot;, #该参数代表数据的分隔符，csv文件默认为逗号，其他常见的&quot;\t&quot; sep= ',', #该参数代表跳过数据文件的第一行不读 skiprows ....................
pandas库基础操作
2302_81096429的博客
09-13 1万+
https://i-blog.csdnimg.cn/direct/cb9976308aa64b50a09393987aadbdb6.png
Pandas——基础操作汇总
weixin_51531943的博客
10-26 322
数据结构&Series： ''' series {索引 + 数据} 形式 索引是自动生成的 ''' #通过 list 创建 s1 = pd.Series([1, 2, 3, 4, 5]) #通过np数组创建 arr1 = np.arange(10) s2 = pd.Series(arr1) #自定义索引 s2 = pd.Series(arr1, index=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']) #单独查看值或索引 prin
pandas基础操作1.0
12-22
本篇主要介绍pandas的基础操作，包括Series和DataFrame的创建，以及Series的切片、索引和读取外部文件。 1. **pandas常用数据类型** - **Series**：Series是一种一维数据结构，类似于一维数组，但每个元素都有一个...
Pandas基础操作.pdf
05-24
以下是一些关于Pandas基础操作的详细说明： 1. **数据读取与加载**： - `read_csv()` 函数用于读取CSV文件，将数据转换为DataFrame对象。 - `read_excel()` 函数则用于读取Excel文件。 2. **数据查看**： - `...
pythonpandas基本操作练习50题.pdf
06-11
在这个"pythonpandas基本操作练习50题"中，我们将重点讨论如何利用Pandas进行数据预览、数据清洗、数据统计以及数据分组等基础操作。 首先，数据预览是分析的起点。`df.head()`函数用于查看数据集的前几行，这有助...
头歌pandas基本操作 看起来您提到的“头歌”可能是
03-20
头歌pandas基本操作 看起来您提到的“头歌”可能是指一个提供编程练习和学习的平台，类似于LeetCode、Codewars等。在这里，我将基于Pandas库的基本操作给出一些指导和示例代码，这些内容可以帮助您在类似“头歌”的...
看起来您可能正在“头歌”平台上进行Pandas基本操作的作业 尽管我无法直接访问具体的平台或作业内容，我可以提供一些常见的Pandas基本操作示例和练习题目，这些可以帮助您更好地理解和完成相关作业
03-21
pandas基本操作头歌作业 看起来您可能正在“头歌”平台上进行Pandas基本操作的作业。尽管我无法直接访问具体的平台或作业内容，我可以提供一些常见的Pandas基本操作示例和练习题目，这些可以帮助您更好地理解和完成...
python pandas的基本使用及基本操作小例子！
12-21
一、生成数据表 1.首先导入pandas库，一般会用到numpy库，所以先导入备用！ import numpy as np import pandas as pd 2.导入CS或者xlsx文件： fandango=pd.read_csv(“自己的路径及文件”，header=1) fandango=pd.DataFrame(pd.read_exce(“name.xlsx”)) 3用pandas创建数据表： import numpy as np import pandas as pd new_pandas=pd.DataFrame({"col1":range(7),"col2":[11,22,33
Python中的pandas库的基础操作与用法
最新发布
橙色小博的博客，励志在人工智能领域发光发热！
03-28 829
Pandas 库不仅能够轻松地处理各种数据读取、清洗、探索、可视化和合并任务，还能够与众多其他数据分析和机器学习库无缝协作，构建出复杂而强大的数据处理流程。在Python数据处理中，Pandas 是我们不可或缺的得力助手。它让数据从杂乱无章的原始状态，经过一系列精细的处理和加工，最终转化为更加有效的数据。我是橙色小博，关注我，一起在人工智能领域学习与前进。
pandas库——基础
Lonelinessser的博客
10-24 2040
Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来Pandas 名字衍生自术语 "panel data"（面板数据）和 "Python data analysis"（Python 数据分析）Pandas 已经成为 Python 数据分析的必备高级工具，它的目标是成为强大、灵活、可以支持任何编程语言的数据分析工具Pandas 是 Python 语言的一个扩展程序库，用于数据分析。
【Python基础】pandas 使用指南（超详细！）
热门推荐
你一定能够成为你想要去成为的人。
02-04 2万+
pandas指南 学习目的： 掌握pandas中series与dataframe pandas数据清洗 使用pandas进行数据基本统计 时间序列分析 数据分析常用方法 1 Pandas基础 pandas是python中数据分析核心库，能够快速，灵活的对大量数据进行分析，是Python进行数据分析的必要利器； pandas支持多种数据导入，支持数据合并，拆分，基本统计，时间序列分析，透视表等多种操作； 1.1 Series数据结构 Series：一维的带索引数据结构(单列) Series类： pd
2万字！Pandas 常用操作图解（非常详细）零基础入门到精通，收藏这一篇就够了
aobulaien001的博客
06-18 3931
Pandas 展示请看下表:它描述了一个在线商店的不同产品线，共有四种不同的产品。与前面的例子不同，它可以用NumPy数组或Pandas DataFrame表示。但让我们看一下它的一些常见操作。
Pandas基础点总结
qq_55461119的博客
05-04 1940
pandas是用于数据分析的开源python库，可以实现数据加载，清洗，转换，统计处理，可视化等功能。而DataFrame和Series是pandas最基本的两种数据结构。DataFrame用来处理结构化数据，Series用来处理单列数据，也可以把DataFrame看作Series对象组成的字典或集合。
pandas 基本操作
01-02
### Pandas 基本操作教程 #### 创建 DataFrame 可以利用 `pd.DataFrame()` 函数创建一个简单的表格结构，即 DataFrame。下面是一个例子： ```python import pandas as pd df = pd.DataFrame({ 'name': ['Xiaoming', 'Xiaohong', 'Xiaojun'], 'age': [18, 35, 45], 'occupation': ['student', 'teacher', 'doctor'] }) print(df) ``` 这段代码展示了如何构建一个包含姓名、年龄以及职业三个字段的数据表[^2]。 #### 修改 DataFrame 对于已有的 DataFrame 可以通过多种方式修改其内容。例如向现有的数据框中追加新记录可以通过设置 `.loc[]` 属性实现： ```python # 向上述 df 中添加一行新的数据 df.loc[3] = ['Xiaoqi', 20, 'student'] print(df) ``` 此部分说明了怎样给定位置插入一条完整的记录到指定索引处，并更新整个数据集的内容。 #### 数据读取与保存 针对 Excel 文件的操作也是 Pandas 的强项之一。能够轻松加载本地磁盘上的 .xlsx 或者其他支持的电子表格文件格式进入内存成为 DataFrame 对象；同样也可以把处理后的结果导出回 Excel 表格里去[^3]。 具体来说，使用 `pd.read_excel('filename.xlsx')` 方法可以从 Excel 文档导入数据而无需担心复杂的解析逻辑；反之则可通过调用 `DataFrame.to_excel('output_filename.xlsx')` 将当前工作区内的对象序列化成标准的工作簿形式存于硬盘上供后续分析或分享用途。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值