Pandas(全网最详细攻略)（Python）

桑落东篱

已于 2024-07-01 14:06:17 修改

阅读量1.5k

点赞数 8

分类专栏： Python 文章标签： pandas python 机器学习数据分析

于 2024-05-27 15:04:33 首次发布

本文链接：https://blog.csdn.net/SzyPy/article/details/139236108

版权

Python 专栏收录该内容

51 篇文章 1 订阅

订阅专栏

前言

Pandas 最初由 AQR Capital Management 于2008年4月开发，并于2009年底开源出来。Pandas 这个名字来源于面板数据（Panel Data）与数据分析（data analysis）这两个名词的组合。在经济学中，Panel Data 是一个关于多维数据集的术语。Pandas 最初被应用于金融量化交易领域，现在它的应用领域更加广泛，涵盖了科学研究、市场营销、社交媒体、医疗保健、教育研究等众多行业。

一、简介

Pandas 是一个免费、开源的数据分析和数据处理库，它是基于 Python 编程语言的。

二、安装

首先为你的终端，下载并安装自己想要的 Python 版本。

1、Anaconda（开源、安装简单、高性能、免费的社区支持）

Anaconda，是一个开源的Python发行版本，其包含了（包管理器）conda、Python等180多个科学包及其依赖项，但是还有一些没有被包含在内的包需要通过 pip 安装；为你的电脑下载并安装 Anaconda，运行安装程序，然后按照步骤操作，安装完成后重启终端。

2、Pycharm（推荐下载社区版（免费使用））

PyCharm 是一种Python IDE（Integrated Development Environment，集成开发环境），带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，比如调试、语法高亮、项目管理、代码跳转、智能提示、自动完成、单元测试、版本控制。此外，该IDE提供了一些高级功能，以用于支持Django框架下的专业Web开发；为你的电脑下载并安装 Pycharm，运行安装程序，然后按照步骤操作，最后安装完成重启终端。

3、pip

pip 是 Python 的包管理工具，该工具提供了对 Python 包的查找、下载、安装、卸载的功能；目前如果你在 python.org 下载最新版本的安装包，则是已经自带了该工具。

pip install pandas

三、数据结构

1、Series

一维数组；与numpy中的一维array类似，二者与Python基本的数据结构List也很相近，以时间为索引的Series：

'''
pandas.Series()
参数：
	data：Series 的数据部分，可以是列表、数组、字典、标量值等。如果不提供此参数，则创建一个空的 Series。
	index：Series 的索引部分，用于对数据进行标记。可以是列表、数组、索引对象等。如果不提供此参数，则创建一个默认的整数索引。
	dtype：指定 Series 的数据类型。可以是 NumPy 的数据类型，例如 np.int64、np.float64 等。如果不提供此参数，则根据数据自动推断数据类型。
	name：Series 的名称，用于标识 Series 对象。如果提供了此参数，则创建的 Series 对象将具有指定的名称。
	copy：是否复制数据。默认为 False，表示不复制数据。如果设置为 True，则复制输入的数据。
	fastpath：是否启用快速路径。默认为 False。启用快速路径可能会在某些情况下提高性能。
'''

'''
方法（1）创建Series
'''
# example
import numpy as np
import pandas as pd
df = pd.Series(data=[18, 19, 30, 40], index=['小明', '小米', '张三', '李四'], dtype=np.int64, name='年龄', copy=False, )
print(df)

2、DataFrame（常用）

二维的表格型数据结构；可以将DataFrame理解为Series的容器，可以被看做由 Series 组成的字典：

'''
pandas.DataFrame()
参数：
	data：DataFrame 的数据部分，可以是字典、二维数组、Series、DataFrame 或其他可转换为 DataFrame 的对象。如果不提供此参数，则创建一个空的 DataFrame。
	index：DataFrame 的行索引，用于标识每行数据。可以是列表、数组、索引对象等。如果不提供此参数，则创建一个默认的整数索引。
	columns：DataFrame 的列索引，用于标识每列数据。可以是列表、数组、索引对象等。如果不提供此参数，则创建一个默认的整数索引。
	dtype：指定 DataFrame 的数据类型。可以是 NumPy 的数据类型，例如 np.int64、np.float64 等。如果不提供此参数，则根据数据自动推断数据类型。
	copy：是否复制数据。默认为 False，表示不复制数据。如果设置为 True，则复制输入的数据。
'''

'''
方法（1）二维列表创建DataFrame
'''
# example
import numpy as np
import pandas as pd
df = pd.DataFrame(data=[[98, 100, 99], [60, 70, 68], [59, 13, 50]], columns=['数学', '线性代数', '数据结构'], dtype=np.int64,
                  copy=False)
print(df)
              
'''--------------------------------------------------------------------------------------------'''

'''
方法（2）：字典嵌套列表创建DataFrame
'''
# example
import pandas as pd
df = pd.DataFrame(data={'Name': ['Tom', 'Jack', 'Steve', 'Ricky'], 'Age': [28, 34, 29, 42]})
print(df)  

'''--------------------------------------------------------------------------------------------'''
               
'''
方法（3）：列表嵌套字典创建DataFrame
'''
# example
import pandas as pd
df = pd.DataFrame(data=[{'数学': 100, '语文': 92}, {'数学': 85, '语文': 90, '英语': 100}])
print(df)

四、基本属性&方法：

方法	返回
dataframe.size	查看DataFrame数组长度
dataframe.ndim	查看DataFrame数组维度
dataframe.shape	返回一个元组，如(3, 3)表示有3行和3列
dataframe.axes	返回一个仅以行轴标签和列轴标签为成员的列表
dataframe.shift()	将行或列移动指定的步幅长度
dataframe.head(1)	返回一个新的DataFrame，展示前1行数据，默认是前5行
dataframe.tail(1)	返回一个新的DataFrame，展示最后1行数据，默认是最后5行
dataframe.index	返回DataFrame的行索引
dataframe.columns	返回DataFrame的列索引列表
dataframe.values	返回DataFrame中所有值组成的NumPy数组
dataframe.info()	展示DataFrame的信息，包括每列的名称、非空值的数量等
dataframe.describe()	提供DataFrame中数值型列的描述性统计信息
dataframe.dtypes	展示DataFrame中每列的数据类型
dataframe.T	转置DataFrame，即行列互换
dataframe.index = list	修改index，必须整体全部修改
dataframe.columns= list	修改columns，必须整体全部修改

1、数据筛选方法

'''
方法（1）：loc（指定行或列的名称才能选择数据）
'''
# example
import pandas as pd
class_one = pd.DataFrame([[1, '小明', 11],
                          [2, '小张', 13],
                          [3, '小赵', 9],
                          [4, '小赵', 12],
                          [5, '小钱', 15]],
                         columns=['id', 'name', 'age'])
class_one = class_one.loc[(class_one['name'] == '小赵') & (class_one['age'] < 10), ['name']]
print(class_one)

'''--------------------------------------------------------------------------------------------'''

'''
方法（2）：布尔遮罩（Boolean masking） 
	一系列 True/False 值，用于根据特定条件从另一个数据结构(如列表、数组或 DataFrame)中筛选或选择元素
'''
# example
import pandas as pd
class_one = pd.DataFrame([[1, '小明', 11],
                          [2, '小张', 13],
                          [3, '小赵', 9],
                          [4, '小赵', 12],
                          [5, '小钱', 15]],
                         columns=['id', 'name', 'age'])
one = (class_one['name'] == '小赵') & (class_one['age'] < 10)
class_one = class_one[one]['name']
print(class_one)

'''--------------------------------------------------------------------------------------------'''

'''
方法（3）：iloc（行和列索引的整数位置，从数据集中选择和提取数据，简化数据切片和子集操作的一种方法）
'''
# example
import pandas as pd
class_one = pd.DataFrame([[1, '小明', 11],
                          [2, '小张', 13],
                          [3, '小赵', 9],
                          [4, '小赵', 12],
                          [5, '小钱', 15]],
                         columns=['id', 'name', 'age'])
result = class_one.iloc[0]  # 选择第一行数据
result = class_one.iloc[:, 0]  # 选择第一列数据
print(result)

'''--------------------------------------------------------------------------------------------'''

'''
方法（4）：isin(values) 
	用于基于其值是否在给定集合 values 中来过滤和选择行
	~ 表示逻辑非
'''
# example
import pandas as pd
customers = pd.DataFrame([[1, '小张', 100],
                          [2, '小明', 2000],
                          [3, '小红', 400],
                          [4, '小赵', 10000]],
                         columns=['id', 'name', 'fee']).astype({'id': 'Int64', 'name': 'object'})
orders = pd.DataFrame([[1, 3],
                       [2, 1]],
                      columns=['id', 'customerId']).astype({'id': 'Int64', 'customerId': 'Int64'})
res = customers[customers['id'].isin(orders['customerId'])]
# res = customers[~customers['id'].isin(orders['customerId'])]
print(res)

'''--------------------------------------------------------------------------------------------'''

'''
方法（5）：str.len()（str相关方法都可以使用）
	用于计算列中字符串的长度
'''
# example
import pandas as pd
tweets = pd.DataFrame([[1, '全国科技工作者日'],
                       [2, '把热爱变成事业，把不可能变成可能。']],
                      columns=['id', '正文']).astype({'id': 'Int64', '正文': 'object'})
tweet = tweets['正文'].str.len() > 15
tweets = tweets[tweet]
print(tweets)

2、插入新列

'''
方法（1）：可以对 DataFrame Series 中的每个单独元素执行的操作
'''
# example
import pandas as pd
class_one = pd.DataFrame([[101, '小明', 13], [53, '小张', None]], columns=['id', 'name', 'age'])
class_one['身高'] = [161, 178]
print(class_one)

'''--------------------------------------------------------------------------------------------'''

'''
方法（2）：DataFrame.insert()
	参数：
		loc: 插入新列位置，原来位置列向右移，类型int
    	column: 插入新列列名
    	value: 新插入列值，如果只有一个值，将所有行设置相同值
    	allow_duplicates: 默认False，检查是否有相同列名
'''
# example
import pandas as pd
class_one = pd.DataFrame([[101, '小明', 13], [53, '小张', None]], columns=['id', 'name', 'age'])
class_one.insert(loc = 3, column = '身高', value = [161, 178])
print(class_one)

3、删除重复的行

'''
方法（1）：DataFrame.drop_duplicates()
	参数：
		subset：指定要考虑重复的列，默认None，表示考虑整张表的重复
		keep：指定保留哪些重复行
			first： (默认) 删除除第一个匹配项以外的重复项。
			last： 删除除最后一个匹配项之外的重复项。
		inplace：默认False，指定是否在原始 DataFrame 上进行修改
		ignore_index：默认False。如果为True，删除后的 DataFrame 将重新索引，以便索引从零开始
'''
# example
import pandas as pd
class_one = pd.DataFrame([[101, '小明', 13], 
						[53, '小张', 10],
						 [53, '小张', 10]], columns=['id', 'name', 'age'])
class_one.drop_duplicates(keep='last', inplace=True, ignore_index=False)
print(class_one)

4、处理缺失的值

'''
方法（1）DataFrame.dropna() 删除
	参数：
		axis： 默认为0
			axis=0：删除包含缺失值的行
			axis=1：删除包含缺失值的列
		how： 默认any
			how='any'： 只要存在一个缺失值就删除整行或整列
			how='all'： 只有当整行或整列都是缺失值时才删除
		thresh： 行或列中的非缺失值数量小于等于thresh，则会被删除
		subset： 用于指定要检查缺失值的特定列名或行索引
		inplace：表示是否对原始数据进行就地修改，默认值为False
'''
# example 
import pandas as pd
class_one = pd.DataFrame([[101, '小明', 13], [53, '小张', None]], columns=['id', 'name', 'age'])
class_one.dropna(inplace=True)
print(class_one)

'''--------------------------------------------------------------------------------------------'''

'''
方法（2）DataFrame.fillna() 填充
	参数：
		value：scalar 或 dict 或 Series 或 DataFrame | optional，要替换 NaN 的值，如果指定了 dict 或 Series，则键/索引是列标签，值是填充符
		method：默认None，{'pad','ffill','backfill','bfill',None}
			pad（ffill）：用前一个非缺失值去填充该缺失值
			backfill（bfill）：用下一个非缺失值填充该缺失值
			None：指定一个值去替换缺失值
		axis：修改填充方向
			 0：index
			 1：columns
		inplace：默认False，指定是否在原始 DataFrame 上进行修改
		limit：限制填充个数
'''
# example 
import pandas as pd
class_one = pd.DataFrame([[101, '小明', 13], [53, '小张', None]], columns=['id', 'name', 'age'])
class_one.fillna(0, inplace=True)
print(class_one)

5、修改列名

'''
方法（1）：DataFrame.rename()
	参数:
		mapper：与axis结合使用，表示运用到axis上的值：类字典或者函数
		axis：指定重命名的轴：0或index；1或columns；默认为0
		index：指定修改行索引，字典的键是原始索引，值是新的索引，相当于(mapper,axis=0)
		columns：指定修改列索引，字典的键是原始索引，值是新的索引，相当于(mapper,aixs=1)
		copy： 默认None，返回重命名后的副本
		inplace：默认False，指定是否在原始 DataFrame 上进行修改
		level： 用于指定需要重命名的多层索引的层级
		errors： 默认ignore，处理不存在的键的方法：{ignore, raise}
'''
# example
import pandas as pd
class_one = pd.DataFrame([[101, '小明', 13], [53, '小张', 10]], columns=['student_id', 'name', 'age'])
class_one = class_one.rename(columns={"student_id": "id"})
print(class_one)

6、修改数据类型

'''
方法（1）：DataFrame.astype()
	参数:
		dtype： 一种数据类型，或列名、或数据类型的字典
		copy： 
			True：返回新分配的对象
			False：旧对象无法强制转换为所需类型的情况下，创建新对象
		errors： 默认设置为raise，控制对提供的数据类型的无效数据引发异常
'''
# example
import pandas as pd
class_one = pd.DataFrame([[101, '小明', 13], [53, '小张', 10]], columns=['id', 'name', 'age'])
class_one.astype({'id': str})
# class_one['id']=class_one['id'].astype(str)
print(class_one)

7、连接数据表

'''
方法（1）：pd.concat()
	参数：
		objs：Series，DataFrame或Panel对象的序列或映射，如果传递了dict，则排序的键将用作键参数
		axis：决定连接的方向，默认为0
			axis=0：垂直(按行)连接
			axis=1：水平(按列)连接
		join：默认为outer，处理其他轴上的索引
			inner：交集
			outer：联合
		ignore_index：默认False，是否使用并置轴上的索引值，其他轴上的索引值在连接中仍然受到尊重
			True：不使用并置轴上的索引值
			False：使用并置轴上的索引值
		keys：序列，默认None，使用传递的键作为最外层构建层次索引；如果为多索引，应该使用元组
		levels：序列列表，默认None，用于构建MultiIndex的特定级别（唯一值）；否则，它们将从键推断
		names：默认None，结果层次索引中的级别的名称，类型list
		verify_integrity：默认False，检查新连接的轴是否包含重复项，类型bool
		copy：默认False，不复制数据，类型bool
'''
# example 上下连接（常用）
import pandas as pd
class_one = pd.DataFrame([[101, '小明', 13], [53, '小张', 10]], columns=['id', 'name', 'age'])
class_two = pd.DataFrame([[3, '李四', 11], [6, '李子', None]], columns=['id', 'name', 'age'])
students = pd.concat([class_one, class_two], axis=0)
print(students)

'''------------------------------------------------------------------------------------------------'''

'''
方法（2）：pd.merge()
	参数：
		left：待拼接的左侧数据框
		right：待拼接的右侧数据框
		how：左右两个数据框的连接方式。可选left、right、outer、inner，默认为inner
		on：左右两个待拼接数据框有共同列名，且按该列拼接两个数据框时使用该参数
		left_on：拼接两个数据框时，左数据框对应连接关键字(可为列表)
		right_on：拼接两个数据框时，右数据框对应连接关键字(可为列表)
		left_index：若为True，则按左数据框的索引连接两个数据框
		right_index：若为True，则按右数据框的索引连接两个数据框
		sort：按字典顺序通过连接键对结果数据框进行排序
		suffixes：为左右数据框中重复列名定义后缀，默认加('x','y')
'''
# example 
import pandas as pd
students = pd.DataFrame([[1, '小张', 1],
                         [2, '小小', 1],
                         [3, '小红', 1],
                         [4, '小赵', 1],
                         [5, '小明', 1]],
                        columns=['学号', '姓名', '班级']).astype({'学号': 'Int64', '姓名': 'str', '班级': 'Int64'})
score = pd.DataFrame([[1, '99', 100],
                      [2, '96', 19],
                      [3, '56', 60],
                      [4, '45', 99],
                      [5, '60', 89]],
                     columns=['学号', '数学', '语文']).astype({'学号': 'Int64', '数学': 'Int64', '语文': 'Int64'})
result = pd.merge(left=students, right=score, on='学号')
print(result)

8、透视数据表

'''
方法（1）：DataFrame.pivot()（pivot 函数不处理相同索引/列组合的重复条目）
	参数：
		index：新 DataFrame 中的行
		columns：新 DataFrame 中的列
		values：指定重塑表格时要使用的值
'''
# example 
import pandas as pd
city = pd.DataFrame({'日期': ['2022', '2023', '2024', '2022', '2023', '2024', '2022', '2023', '2024'],
                     '城市': ['上海', '上海', '上海', '北京', '北京', '北京', '南京', '南京', '南京'],
                     'GDP(万亿)': [3, 6, 9, 6, 12, 15, 6, 7, 10]})
city = city.pivot(index='日期', columns='城市', values='GDP(万亿)')
print(city)

'''------------------------------------------------------------------------------------------------'''

'''
方法（2）：DataFrame.pivot_table()
	参数：
		index：新 DataFrame 中的行
		columns：新 DataFrame 中的列
		values：指定重塑表格时要使用的值，聚合统计的值
		aggfunc：聚合的方法，默认mean
		fill_value：用于替换空值的值，默认None
		margins：类型bool, 是否生成汇总行，默认False
		dropna：如果列的所有值都是NaN，将不作为计算列，默认True
		margins_name：汇总行的命名
		observed：是否显示观测值，默认False
		sort：是否排序，默认True
'''
# example
import pandas as pd
city = pd.DataFrame({'日期': ['2022', '2022', '2024', '2022', '2023', '2024', '2022', '2024', '2024'],
                     '城市': ['上海', '上海', '上海', '北京', '北京', '北京', '南京', '南京', '南京'],
                     'GDP(万亿)': [3, 6, 9, 6, 12, 15, 6, 7, 10]})
city = city.pivot_table(index='日期', columns='城市', values='GDP(万亿)', aggfunc='sum')
print(city)

'''------------------------------------------------------------------------------------------------'''

'''
方法（3）：DataFrame.melt()（将DataFrame从宽格式转换成长格式）
	参数：
		id_vars：指定了应该保持不变的列
		value_vars：指定了我们想要melt或将其整形成行的列
		var_name：存储来自 value_vars 的标头名称的新列的名称
		value_name：存储 value_vars 中的值的新列的名称
		col_level：如果列是多层索引，melt将应用于指定级别
		ignore_index：默认为True，相当于从0开始重新排序。如果为False，则保留原来的索引，索引标签将出现重复
'''
# example
import pandas as pd
result= pd.DataFrame([['数学', 99, 100, 78, 95],
                     ['语文', 99, 100, 78, 95],
                     ['英语', 99, 100, 78, 95]],
                    columns=['课程', '小张', '小明', '小红', '小赵'])
result= result.melt(
    id_vars=["课程"],
    value_vars=result.columns.tolist()[1:],
    var_name='姓名',
    value_name='成绩'
)
print(result)

9、排序

'''
方法（1）：DataFrame.sort_values()
	参数：
		by：指定要进行排序的列名或索引值
		axis：默认axis=0
			axis=0 或 index：则按照指定列的数据大小排序
			axis=1 或 columns：则按照指定索引中数据大小排序
		ascending：默认为True，如果这是一个 bool 列表，则必须匹配 by 的长度
			ascending=True：则按照升序排序
			ascending=False：则按降序排序
		inplace：排序后的数据是否替换原来的数据，默认为False，即不替换
		ignore_index：是否重置索引，默认为不重置
'''
# example
import pandas as pd
result = pd.DataFrame([[1, '数学', 100],
                       [2, '数学', 19],
                       [3, '数学', 60],
                       [4, '数学', 99],
                       [5, '数学', 89]],
                      columns=['id', '课程', '分数']).astype({'id': 'Int64', '课程': 'str', '分数': 'Int64'})
result = result.sort_values(by='分数')
print(result)

'''------------------------------------------------------------------------------------------------'''

'''
方法（2）：DataFrame.rank()
	参数：
		axis：0或index，1或columns，默认0，沿着行或列计算排名
		method：默认average，如何对具有相同值的记录组进行排名
			average：组的平均等级
			min：组中最低的排名
			max：组中最高等级
			first：按排列顺序排列，依次排列
			dense：类似于 min，但组之间的排名始终提高1
		numeric_only：是否仅仅计算数字型的columns
		na_option：默认keep，NaN值是否参与排名及如何排名
			keep：将NaN等级分配给NaN值
			top：如果升序，则将最小等级分配给NaN值
			bottom：如果升序，则将最高等级分配给NaN值
		ascending：默认True，元素是否应该按升序排名
		pct：默认False，是否以百分比形式显示返回的排名
'''
# example
import pandas as pd
result = pd.DataFrame([[1, '数学', 100],
                       [2, '数学', 100],
                       [3, '数学', 60],
                       [4, '数学', 99],
                       [5, '数学', 89]],
                      columns=['id', '课程', '分数']).astype({'id': 'Int64', '课程': 'str', '分数': 'Int64'})
result['rank'] = result['分数'].rank(method='min')
print(result)

10、数据分组

'''
方法（1）：DataFrame.groupby()
	参数：
		by：指定分组依据
		axis：默认0，用于指定分割方向
			0 or index: 按行索引分割
			1 or columns： 按列索引分割
		level：指定多层索引的层级编号或层级名称
		as_index：排序方法（升序或降序）
		sort：是否对组名排序
		group_keys：是否返回组键，default True
			group_keys=True，分组的键会作为结果的索引
			group_keys=False，分组的键不会作为索引
		observed：只显示观测值或显示所有值
			True: 只显示分类分组器（groupers）的观察值（observed values），而不显示未观察到的值
			False: 则显示所有分类分组器的可能值，包括未在实际数据中观察到的值。
		dropna：用于控制 groupby 对象的行数索引是否可以包含缺失值，舍弃缺失值的动作，是在分组前完成的
			True，如果组键包含缺失值，则将缺失值与行/列一起删除
			False，保留缺失值
'''
# example
import pandas as pd

result = pd.DataFrame([['一班', '小张', 178, 130],
                       ['一班', '小明', 168, 110],
                       ['一班', '小红', 160, 90],
                       ['二班', '小红', 160, 90],
                       ['二班', '小赵', 160, 90]],
                      columns=['班级', '姓名', '身高', '体重'])
# result = result.groupby(by='班级')['身高'].mean().reset_index()
result = result.groupby(by='班级').agg({'身高': 'mean', '体重': 'mean'})
print(result)

11、处理excel

'''
方法（1）：pandas.read_excel()
	参数：
		io：读取文件的绝对路径，str，Excel文件，xlrd.Book，路径对象或类似文件的对象
		sheetname：通过sheet位置或sheet名字来指定读入哪个sheet的数据，默认0，获取第一个工作表
		header：用第几行作为表头，默认header=0，即默认第一行为表头
		names：自定义表头的名称，需要传递数组参数
		index_col：指定列为索引列，默认为None，也就是索引为0的列用作DataFrame的行标签
		usecols：默认为None，解析所有列
			如果为str，则表示Excel列字母和列范围的逗号分隔列表（usecols='A,C,E'），范围全闭
			如果为int，则表示解析到第几列
			如果为int列表，则表示解析那几列
		squeeze：默认为False。如果设置squeeze=True则表示如果解析的数据只包含一列，则返回一个Series
		dtype：列的类型名称或字典，默认为None，也就是不改变数据类型
		engine：指定解析数据时使用的引擎，默认为None，pandas会自动判断数据格式进行引擎的使用
			xlrd支持旧式的Excel文件，如xls文件，pandas1.2.0发生变化，xlrd引擎现在只支持解析xls文件
			openpyxl支持较新的Excel文件格式
			odf支持OpenDocument文件格式如odf，ods，odt
			pyxlsb支持二进制Excel文件
		converters：对指定列的数据进行指定函数的处理，传入参数为列名与函数组成的字典
		true_values：将指定的文本转换为True，默认为None
		false_values：将指定的文本转换为False，默认为None，（将性别中的女转换为True，男转换为False）
		skiprows：跳过指定的行，第一行开始（skiprows=lambda x: x % 2 == 0 ；跳过偶数行）
		nrows：默认为None，指定需要读取前多少行，通常用于较大的数据文件中
		na_values：指定某些列的某些值为NaN
		na_filter：检测缺失值
		keep_default_na：导入数据时是否导入空值，默认为True，即自动识别空值并导入
		verbose：显示列表中除去数字列，NA值的数量
		parse_dates：默认值False，解析的日期
		date_parser：用于将字符串列转换为datetime实例的函数，默认使用dateutil.parser.parser进行转换
		thousands：默认值None，千分位符
		comment：设置注释符号，注释掉行的其余内容。将一个或多个字符串传递给此参数以在输入文件中指示注释
			注释字符串与当前行结尾之间的任何数据都将被忽略
		skipfooter：跳过指定的行，最后一行开始
		convert_float：默认为 True，将浮点整数转换为整数，如果为False，则所有数字数据都将作为浮点数读取
		mangle_dupe_cols：默认值True，当列名有重复时，将列名解析为‘X’, ‘X.1’, …’X.N’
			如果该参数为False，那么当列名中有重复时，前列会被后列覆盖
'''
# example
import pandas as pd
df = pd.read_excel(r'excel文件路径')
print(df)

'''------------------------------------------------------------------------------------------------'''

'''
方法（2）：DataFrame.to_excel()
	参数：
		excel_writer: 用来指定写入文件的路径和文件名，路径支持相对路径和绝对路径
        sheet_name: 指定输出表格存放的工作表名称，默认为'Sheet1'
        na_rep:设置缺失数据的表示方式，默认为空字符串
        float_format: 用于格式化浮点数字符串
        columns: 设置要写入文件的列，默认为None，表示写入全部列
        header: 是否写入表头，也可重新设置表头
        	True（默认）：写入表头，保持原有表头内容不变
        	False：不写入表头，从输出文件的第一行开始就写入数据
        	字符串列表：写入表头，但将表头中的各列名称重新命名
        index: 是否写入索引列作为输出表格的第一列，默认为True，通常设置为False
        index_label: 仅当index=True时有效，设置（或重设）索引列的名称放在表头，默认为None，即保持原有列名（在读入时以index_col选项指定的索引列名，未指定则为空白）
        startrow: 用于设定写入Excel文件的起始行数（均从0开始编号）
        startcol: 用于设定写入Excel文件的起始列数（均从0开始编号）
        engine: 用于写入Excel的引擎，默认为openpyxl
        merge_cells: 是否合并单元格，默认为True
        inf_rep: 默认值为inf，它通常表示无穷大
        freeze_panes: 用于指定要冻结的最底部一行和最右边一列
        storage_options: 字典，可选，对特定存储连接（例如主机、端口、用户名、密码等）有意义的额外选项
        engine_kwargs:
'''
import pandas as pd
data = {'Name': ['小赵', '小明', '小红'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)
df.to_excel('excel路径', index=False)

总结

如果该篇文章有，没有涉及到的地方（Pandas相关内容），可以评论留言提醒，我会及时更新！💪
Pandas 官网： https://pandas.pydata.org/
Pandas 源代码：https://github.com/pandas-dev/pandas
Leetcode 官网：https://leetcode.cn/

桑落东篱

关注

8
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
2
评论
Pandas(全网最详细攻略)（Python）

Pandas 最初由 AQR Capital Management 于2008年4月开发，并于2009年底开源出来，当时由专注于 Python 数据包开发的 PyData 开发团队继续开发和维护，属于 PyData 项目的一部分。Pandas 最初被作为金融数据分析工具而开发出来，因此，Pandas 为时间序列分析提供了很好的支持。Pandas 的名称来自于面板数据（panel data）和 python 数据分析（data analysis）。
复制链接

扫一扫