一、Pandas基础
文章目录
1、概述
- Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来
- Pandas 名字衍生自术语 “panel data”（面板数据）和 “Python data analysis”（Python 数据分析）
- Pandas 已经成为 Python 数据分析的必备高级工具，它的目标是成为强大、灵活、可以支持任何编程语言的数据分析工具
- Pandas 是 Python 语言的一个扩展程序库，用于数据分析
- Pandas 是一个开放源码、BSD 许可的库，提供高性能、易于使用的数据结构和数据分析工具
- Pandas 一个强大的分析结构化数据的工具集，基础是 Numpy（提供高性能的矩阵运算）
- Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据
- Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征
- Pandas 广泛应用在学术、金融、统计学等各个数据分析领域
- Pandas 的出现使得 Python 做数据分析的能力得到了大幅度提升，它主要实现了数据分析的五个重要环节：加载数据、整理数据、操作数据、构建数据模型、分析数据
2、安装
pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/
3、内置数据结构
Pandas 在 ndarray 数组（NumPy 中的数组）的基础上构建出了两种不同的数据结构，分别是 Series（一维数据结构）、DataFrame（二维数据结构）：
- Series 是带标签的一维数组，这里的标签可以理解为索引，但这个索引并不局限于整数，它也可以是字符类型，比如 a、b、c 等
- DataFrame 是一种表格型数据结构，它既有行标签，又有列标签
| 数据结构 | 维度 | 说明 |
|---|---|---|
| Series | 1 | 该结构能够存储各种数据类型，比如字符数、整数、浮点数、Python 对象等，Series 用 name 和 index 属性来描述数据值。Series 是一维数据结构，因此其维数不可以改变 |
| DataFrame | 2 | DataFrame 是一种二维表格型数据的结构，既有行索引，也有列索引。行索引是 index，列索引是 columns。 在创建该结构时，可以指定相应的索引值 |
4、Series
Pandas Series 类似表格中等一个列（column），类似于一维数组，可以保存任何数据类型 Series 由索引（index）和列组成，函数：
| 函数名 | 参数 |
|---|---|
| pandas.Series(data,index,dtype) | data：一组数据（ndarray 类型） index：数据索引标签，如果不指定，默认从 0 开始 dtype：数据类型，默认会自己判断 copy：表示对 data 进行拷贝，默认为 False |
4.1 创建 Series 对象的方式
4.1.1 创建 Series 空对象
import pandas as pd
# Series 空对象
def one():
series_one = pd.Series(dtype='f8')
print('空对象：\n', series_one)
直接赋值创建Series 对象
series_one = pd.Series([1,2,3,4,5], dtype='f8')
print('Series对象：\n', series_one)
4.1.2 ndarray 创建 Series 对象
import pandas as pd
import numpy as np
array_one = np.array(['小明', '小红', '小紫'])
series_one = pd.Series(data=array_one)
print('ndarray 创建 Series 对象：')
print(series_one)
# 输出：
0 小明
1 小红
2 小紫
dtype: object
4.1.3 字典创建 Series 对象
import pandas as pd
# 字典创建 Series 对象
data = {"name": "zhangsan", "gender": "男"}
result = pd.Series(data=data)
print('字典创建 Series 对象：')
print(result)
# 输出：
name zhangsan
gender 男
dtype: object
4.1.4 标量创建 Series 对象
# 标量创建 Series 对象
def four():
result = pd.Series(data=5,index=[1,2,3,4,5])
print('标量创建 Series 对象：')
print(result)
# 输出：
'''
1 5
2 5
3 5
4 5
5 5
dtype: int64
'''
4.2 访问 Series 数据
import pandas as pd
def five():
data = {"name": "陈蕾", "gender": "男"}
result = pd.Series(data=data)
print(result["name"])
print(result[1])
4.3 Series 常用属性
| 名称 | 属性 |
|---|---|
| axes | 以列表的形式返回所有行索引标签 |
| dtype | 返回对象的数据类型 |
| empty | 返回一个布尔值，用于判断数据对象是否为空 |
| ndim | 返回输入数据的维数 |
| size | 返回输入数据的元素数量 |
| values | 以 ndarray 的形式返回 Series 对象 |
| index | 返回一个RangeIndex对象，用来描述索引的取值范围 |
案例：
import pandas as pd
def six():
result = pd.Series(['a','b','c','d','e'])
print("以列表的形式返回所有行索引标签：",result.axes)
print("返回对象的数据类型：",result.dtype)
print("返回一个布尔值，用于判断数据对象是否为空",result.empty)
print("返回输入数据的维数：",result.ndim)
print("返回输入数据的元素数量：",result.size)
print("以 ndarray 的形式返回 Series 对象：",result.values)
print("返回一个 RangeIndex 对象，用来描述索引的取值范围：",result.index)
'''
以列表的形式返回所有行索引标签： [RangeIndex(start=0, stop=5, step=1)]
返回对象的数据类型： object
返回一个布尔值，用于判断数据对象是否为空 False
返回输入数据的维数： 1
返回输入数据的元素数量： 5
以 ndarray 的形式返回 Series 对象： ['a' 'b' 'c' 'd' 'e']
返回一个 RangeIndex 对象，用来描述索引的取值范围： RangeIndex(start=0, stop=5, step=1)
'''
4.4 Series 常用方法
4.4.1 head() 和 tail()
查看 Series 的某一部分数据，使用 head() 或者 tail() 方法。其中 head() 返回前 n 行数据，默认显示前 5 行数据，tail() 返回后 n 行数据，默认为后 5 行
案例：
import pandas as pd
# head() 返回前 n 行数据，默认显示前 5 行数据，tail() 返回后 n 行数据，默认为后 5 行
def seven():
result = pd.Series(['a','b','c','d','e','f'])
print("head() 返回前 5 行数据：")
print(result.head())
print("tail() 返回后 5 行数据：")
print(result.tail())
'''
head() 返回前 5 行数据：
0 a
1 b
2 c
3 d
4 e
dtype: object
tail() 返回后 5 行数据：
1 b
2 c
3 d
4 e
5 f
dtype: object
'''
4.4.2 isnull() 和 nonull()
isnull() 和 nonull() 用于检测 Series、DataFrame 中的缺失值。所谓缺失值，顾名思义就是值不存在、丢失、缺少
- isnull()：如果为值不存在或者缺失，则返回 True
- notnull()：如果值不存在或者缺失，则返回 False
案例：
import pandas as pd
'''
isnull() 和 nonull() 用于检测 Series 中的缺失值
isnull()：如果为值不存在或者缺失，则返回 True
notnull()：如果值不存在或者缺失，则返回 False
'''
def eight():
result = pd.Series(['a','b','c','d','e','f',None])
print("isnull()如果为值不存在或者缺失，则返回 True：")
print(result.isnull())
print("notnull()如果值不存在或者缺失，则返回 False：")
print(result.notnull())
#过滤掉缺失值
print(result[result.notnull()])
'''
isnull()如果为值不存在或者缺失，则返回 True：
0 False
1 False
2 False
3 False
4 False
5 False
6 True
dtype: bool
notnull()如果值不存在或者缺失，则返回 False：
0 True
1 True
2 True
3 True
4 True
5 True
6 False
dtype: bool
0 a
1 b
2 c
3 d
4 e
5 f
dtype: object
'''
5、DataFrame
-
DataFrame 一个表格型的数据结构，既有行标签（index），又有列标签（columns），它也被称异构数据表，所谓异构，指的是表格中每列的数据类型可以不同，比如可以是字符串、整型或者浮点型等。其结构图示意图，如下所示：
-
DataFrame 的每一行或列数据都可以看成一个 Series 结构，只不过，DataFrame 为这些行中每个数据值增加了一个列或行标签
-
同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应当然你也可以用“显式索引”的方式来设置行标签
-
DataFrame 构造方法如下：
| 函数名 | 参数 |
|---|---|
| pd.DataFrame( data, index, columns, dtype, copy) | data：一组数据（ndarray、series, map, lists, dict 等类型） index：索引值，或者可以称为行标签 coumns：列标签，默认为 RangeIndex （0, 1, 2, …, n） dtype：数据类型 copy：默认为 False，表示复制数据 data |
Dataframe和Series的关系：
在 Pandas 中，DataFrame 的每一行或每一列都是一个 Series。
DataFrame 是一个二维表格，可以看作是由多个 Series 组成的。
如何区分行和列的 Series：
列的 Series：
- 标签是行索引。
- 值是该列的所有行数据。
行的Series：
- 标签是列名。
- 值是该行的所有列数据。
示例：
# 创建一个 DataFrame
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data)
# 列的 Series
print(df['A']) # 标签是行索引，值是列 A 的所有行数据
# 行的 Series
print(df.loc[0]) # 标签是列名，值是第 0 行的所有列数据
# 输出：
'''
0 1
1 2
2 3
Name: A, dtype: int64
A 1
B 4
C 7
Name: 0, dtype: int64
'''
5.1 创建 DataFrame 对象
创建 DataFrame 对象的方式：
- 列表
- 字典
- Series
- Numpy ndarrays
- 另一个 DataFrame
5.1.1 创建 DataFrame 空对象
import pandas as pd
# 创建 DataFrame 空对象
def one():
result = pd.DataFrame()
print(result)
5.1.2 列表创建 DataFrame 对象
案例：
import pandas as pd
# 列表创建 DataFrame 对象
def three():
data = ['小明','小红','小紫']
column = ['name']
result = pd.DataFrame(data=data,columns=column)
print(result)
5.1.2 列表嵌套列表创建 DataFrame 对象
案例：
import pandas as pd
# 列表创建 DataFrame 对象
def three():
data = [['小米', 18], ['小红', 19], ['小紫', 20]]
result = pd.DataFrame(data=data,columns=['name','age'])
print(result)
5.1.3 列表嵌套字典创建 DataFrame 对象
**案例：**如果其中某个元素值缺失，也就是字典的 key 无法找到对应的 value，将使用 NaN 代替。
import pandas as pd
# 列表嵌套字典创建 DataFrame 对象
def four():
data = [{'name': "张三", 'age': 18},{'name': "小红", 'gender': "男", 'age': 19}]
result = pd.DataFrame(data=data)
print(result)
# 输出：
'''
name age gender
0 张三 18 NaN
1 小红 19 男
'''
案例2：创建Dataframe，指定列
data = [{'name': "张三", 'age': 18},{'name': "小红", 'gender': "男", 'age': 19}]
result = pd.DataFrame(data=data,columns=['name','age'])
result1 = pd.DataFrame(data=data,columns=['name','gender'])
print(result)
print(result1)
'''
name age
0 张三 18
1 小红 19
name gender
0 张三 NaN
1 小红 男
'''
5.1.4 字典嵌套列表创建 DataFrame 对象
案例：
import pandas as pd
# 典创建 DataFrame 对象
def five():
data = {"name":['小米','小红','小紫'],"age":[18,19,20]}
result = pd.DataFrame(data=data)
print(result)
'''
name age
0 小米 18
1 小红 19
2 小紫 20
'''
5.1.5 Series 创建 DataFrame 对象
**案例：**对于 one 列而言，此处虽然显示了行索引 ‘d’，但由于没有与其对应的值，所以它的值为 NaN。
import pandas as pd
# Series 创建 DataFrame 对象
def seven():
data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
print(result)
'''
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
'''
第一列Series比第二列少一个元素，则以NaN填充，数据类型转换为float
5.2 列索引操作
DataFrame 可以使用列索（columns index）引来完成数据的选取、添加和删除操作
5.2.1 选取数据
import pandas as pd
# 选取数据
def eight():
data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
print(result)
print(result['one'])
'''
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
a 1.0
b 2.0
c 3.0
d NaN
Name: one, dtype: float64
'''
5.2.2 添加数据
**案例1：**添加一列空列
import pandas as pd
import numpy as np
data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
result['three'] = None
print(result)
'''
one two three
a 1.0 1 None
b 2.0 2 None
c 3.0 3 None
d NaN 4 None
'''
**案例2：**添加新列，直接赋值添加
import pandas as pd
data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
# 直接赋值添加，注意：列表长度要和Dataframe的行数一致，否则报错
result['three'] = [1,2,3,4]
print(result)
'''
one two three
a 1.0 1 1
b 2.0 2 2
c 3.0 3 3
d NaN 4 4
'''
**案例3：**通过assign方法添加新列
assign 方法可以用于添加新列，并且可以链式调用。
import pandas as pd
data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
# 注意：列表长度要和Dataframe的行数一致，否则报错
result = result.assign(three = [1,2,3,4])
print(result)
'''
one two three
a 1.0 1 1
b 2.0 2 2
c 3.0 3 3
d NaN 4 4
'''
**案例4：**通过Series添加新列
import pandas as pd
# 添加数据
data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
result['three'] = pd.Series(data=[11, 22, 33], index=['a', 'b', 'c'])
print("使用 df['列'] = 值，插入新的数据列：")
print(result)
'''
使用 df['列'] = 值，插入新的数据列：
one two three
a 1.0 1 11.0
b 2.0 2 22.0
c 3.0 3 33.0
d NaN 4 NaN
'''
案例5：在指定的位置插入新列
使用insert方法在指定位置插入新列，参数：
- loc: 插入位置的列索引。
- column: 新列的名称。
- value: 要插入的 Series。
import pandas as pd
# 创建一个 DataFrame
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])
# 使用 insert 方法在位置 1 插入新列 'D'
df.insert(1, 'D', [13, 14, 15, 16])
print("插入新列后的 DataFrame:")
print(df)
'''
插入新列后的 DataFrame:
A D B C
a 1 13 5 9
b 2 14 6 10
c 3 15 7 11
d 4 16 8 12
'''
5.2.3 修改数据
案例1：修改列的值
import pandas as pd
# 修改数据
def ten():
data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
print(result)
result['two'] = pd.Series(data=[1,2,3],index=['a','b','c'])
print("修改数据：")
print(result)
'''
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
修改数据：
one two
a 1.0 1.0
b 2.0 2.0
c 3.0 3.0
d NaN NaN
'''
案例2：基于现有列的值修改列
import pandas as pd
data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
# 将one列的值加100赋给two列
result['two'] = result['one'] + 100
print(result)
'''
one two
a 1.0 101.0
b 2.0 102.0
c 3.0 103.0
d NaN NaN
'''
案例3：修改列名
import pandas as pd
data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
result.columns = ['A','B']
print(result)
'''
A B
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
'''
案例4：使用 rename 方法修改列名
import pandas as pd
data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
result = result.rename(columns={'one':'A','two':'B'})
print(result)
''' A B
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
'''
案例3与案例4不同：案例3直接修改dataframe的列名，案例4修改列名后生成一个副本，原dataframe不受影响
案例5：修改列的数据类型
import pandas as pd
import numpy as np
data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
result['two'] = result['two'].astype(np.float32)
print(result)
'''
one two
a 1.0 1.0
b 2.0 2.0
c 3.0 3.0
d NaN 4.0
'''
5.2.4 删除数据
. 通过drop方法删除 DataFrame 中的数据，默认情况下，drop() 不会修改原 DataFrame，而是返回一个新的 DataFrame。
语法：
DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')
参数：
- labels：
- 类型：单个标签或列表。
- 描述：要删除的行或列的标签。如果 axis=0，则 labels 表示行标签；如果 axis=1，则 labels 表示列标签。
- axis：
- 类型：整数或字符串，默认为 0。
- 描述：指定删除的方向。axis=0 或 axis=‘index’ 表示删除行，axis=1 或 axis=‘columns’ 表示删除列。
- index：
- 类型：单个标签或列表，默认为 None。
- 描述：要删除的行的标签。如果指定，则忽略 labels 参数。
- columns：
- 类型：单个标签或列表，默认为 None。
- 描述：要删除的列的标签。如果指定，则忽略 labels 参数。
- level：
- 类型：整数或级别名称，默认为 None。
- 描述：用于多级索引（MultiIndex），指定要删除的级别。
- inplace：
- 类型：布尔值，默认为 False。
- 描述：如果为 True，则直接修改原 DataFrame，而不是返回一个新的 DataFrame。
- errors：
- 类型：字符串，默认为 ‘raise’。
- 描述：指定如何处理不存在的标签。‘raise’ 表示抛出错误，‘ignore’ 表示忽略错误。
- 删除数据，使用drop删除行或列，也可以使用切片[::]操作
import pandas as pd
import numpy as np
#drop 删除数据
result=pd.DataFrame()
result['one'] = pd.Series(data=[1, 2, 3], index=['a', 'b', 'c'])
result['two'] = pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
#删除行
result1=result.drop(['one'],axis=1)
#删除行
result2=result.drop(['a'],axis=0)
#删除原DataFrame
result3=result.drop(['a'],axis=0,inplace=True)
print('原表格：\n',result)
print('')
print('删除列\n',result1)
print('删除行\n',result2)
print('全删\n',result3)
# drop是返回一个新的DataFrame
print('原来的DataFrame不变\n',result)
'''
原表格：
one two
b 2 2
c 3 3
删除列
two
a 1
b 2
c 3
删除行
one two
b 2 2
c 3 3
全删
None
原来的DataFrame不变
one two
b 2 2
c 3 3
'''
5.3 行索引操作
5.3.1 loc 选取数据
df.loc[] 只能使用标签索引，不能使用整数索引。当通过标签索引的切片方式来筛选数据时，它的取值前闭后闭，也就是只包括边界值标签（开始和结束）
loc方法返回的数据类型：
1.如果选择单行或单列，返回的数据类型为Series
2.选择多行或多列，返回的数据类型为DataFrame
3.选择单个元素(某行某列对应的值)，返回的数据类型为该元素的原始数据类型（如整数、浮点数等）。
语法：
DataFrame.loc[row_indexer, column_indexer]
参数：
- row_indexer：行标签或布尔数组。
- column_indexer：列标签或布尔数组。
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])
print('原数据为\n',df,'\n')
# 使用 loc 选择数据
print(df.loc['a']) # 选择行标签为 'a' 的行
print(df.loc['a':'c']) # 选择行标签从 'a' 到 'c' 的行
print(df.loc['a', 'B']) # 选择行标签为 'a'，列标签为 'B' 的元素
print(df.loc[['a', 'c'], ['A', 'C']]) # 选择行标签为 'a' 和 'c'，列标签为 'A' 和 'C' 的数据
'''
原数据为
A B C
a 1 5 9
b 2 6 10
c 3 7 11
d 4 8 12
A 1
B 5
C 9
Name: a, dtype: int64
A B C
a 1 5 9
b 2 6 10
c 3 7 11
5
A C
a 1 9
c 3 11
'''
5.3.2 iloc 选取数据
iloc 方法用于基于位置（integer-location based）的索引，即通过行和列的整数位置来选择数据。
语法：
DataFrame.iloc[row_indexer, column_indexer]
参数：
- row_indexer：行位置或布尔数组。
- column_indexer：列位置或布尔数组。
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])
# 使用 iloc 选择数据
print(df.iloc[0]) # 选择第 0 行的数据
print(" ")
print(df.iloc[0:2]) # 选择第 0 到 1 行的数据
print(" ")
print(df.iloc[0, 1]) # 选择第 0 行，第 1 列的元素
print(" ")
print(df.iloc[[0, 2], [0, 2]]) # 选择第 0 和 2 行，第 0 和 2 列的数据
'''
A 1
B 5
C 9
Name: a, dtype: int64
A B C
a 1 5 9
b 2 6 10
5
A C
a 1 9
c 3 11
'''
例子：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3, 4,5,8],
'B': [5, 6, 7, 8,6,9],
'C': [9, 10, 11, 12,4,32],
'D': [9, 10, 11, 12,3,56],
'E': [9, 13, 13, 12,5,23],
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd','e','f'])
# 使用 df[0:2] 选择前两行
result = df[0:2]
print(df)
print('---------')
print(type(result)) # 输出: <class 'pandas.core.frame.DataFrame'>
print(result)
print('---------')
print(df[2:4])
print('---------')
print(df.iloc[2,4])
print('---------')
print(df.iloc[[0,2],[0,4]])
print('---------')
print(df.iloc[0,0:2])
print('---------')
print(df.iloc[0:2,0:2])
'''
A B C D E
a 1 5 9 9 9
b 2 6 10 10 13
c 3 7 11 11 13
d 4 8 12 12 12
e 5 6 4 3 5
f 8 9 32 56 23
---------
<class 'pandas.core.frame.DataFrame'>
A B C D E
a 1 5 9 9 9
b 2 6 10 10 13
---------
A B C D E
c 3 7 11 11 13
d 4 8 12 12 12
---------
13
---------
A E
a 1 9
c 3 13
---------
A 1
B 5
Name: a, dtype: int64
---------
A B
a 1 5
b 2 6
'''
5.3.3 切片多行选取
通过切片的方式进行多行数据的选取
案例：
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])
# 使用 df[0:2] 选择前两行
result = df[0:2]
print(type(result)) # 输出: <class 'pandas.core.frame.DataFrame'>
print(result)
切片获取行和通过iloc方法获取行从结果上没有区别，切片是基于位置的切片操作，iloc是基于位置的索引操作。
5.3.4 添加数据行
5.3.4.1 loc()添加新行
使用loc方法添加新行
# 创建一个 DataFrame
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])
# 添加新行 'e'
df.loc['e'] = [17, 18, 19, 20]
print("添加新行后的 DataFrame:")
print(df)
5.3.4.2 concat() 连接DataFrame或Series
语法：
pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)
参数：
objs: 要连接的 DataFrame 或 Series 对象的列表或字典。
axis: 指定连接的轴，0 或 ‘index’ 表示按行连接，1 或 ‘columns’ 表示按列连接。
join: 指定连接方式，‘outer’ 表示并集（默认），‘inner’ 表示交集。
ignore_index: 如果为 True，则忽略原始索引并生成新的索引。
keys: 用于在连接结果中创建层次化索引。
levels: 指定层次化索引的级别。
names: 指定层次化索引的名称。
verify_integrity: 如果为 True，则在连接时检查是否有重复索引。
sort: 如果为 True，则在连接时对列进行排序。
copy: 如果为 True，则复制数据。
- 按行连接（垂直堆叠）按列连接（水平堆叠）,使用 ignore_index生成新的行，列标签
import pandas as pd
df1 = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
})
df2 = pd.DataFrame({
'A': [7, 8, 9],
'B': [10, 11, 12]
})
#，按行拼接（增加行数），竖直方向上下拼接两DataFrame,并且生成新的行标签
#直接拼接会导致行标签出现重复，为了避免这种情况，使用ignore_index='True'来生成新的行标签
print(pd.concat([df1,df2],axis=0))
# A B
# 0 1 4
# 1 2 5
# 2 3 6
# 0 7 10
# 1 8 11
# 2 9 12
result = pd.concat([df1,df2],axis=0,ignore_index='True')
print(result,'\n')
#按列拼接（增加列数），水平方向左右拼接两个DataFrame，并生成新的列标签
result2=pd.concat([df1,df2],axis=1,ignore_index='True')
print(result2)
'''
A B
0 1 4
1 2 5
2 3 6
3 7 10
4 8 11
5 9 12
0 1 2 3
0 1 4 7 10
1 2 5 8 11
2 3 6 9 12
'''
5.3.4.3 join=’ ',求交并集
使用 join=‘inner’，交集，相同的合并,
使用join=" outer"合并，并集，会补充缺失的位置为None
# 创建两个示例 DataFrame
df1 = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
}, index=[0, 1, 2])
df2 = pd.DataFrame({
'A': [7, 8, 9],
'B': [10, 11, 12],
'D': [13, 14, 15]
}, index=[1, 2, 3])
# 按行合并，只匹配column（列标签）相同的列，行被堆叠
result = pd.concat([df1, df2], axis=0, join='inner')
print(result)
# 按列合并，只匹配index（行标签）相同的行，列被堆叠
result = pd.concat([df1, df2], axis=1, join='inner')
print(result)
print(pd.concat([df1,df2], axis=0, join='outer'))
print(pd.concat([df1,df2], axis=1, join='outer'))
'''
A B
0 1 4
1 2 5
2 3 6
1 7 10
2 8 11
3 9 12
A B A B D
1 2 5 7 10 13
2 3 6 8 11 14
A B D
0 1 4 NaN
1 2 5 NaN
2 3 6 NaN
1 7 10 13.0
2 8 11 14.0
3 9 12 15.0
A B A B D
0 1.0 4.0 NaN NaN NaN
1 2.0 5.0 7.0 10.0 13.0
2 3.0 6.0 8.0 11.0 14.0
3 NaN NaN 9.0 12.0 15.0
'''
5.3.4.4 Dataframe和Series的连接
# 创建一个示例 DataFrame
df = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
})
# 创建一个示例 Series
series = pd.Series([7, 8, 9], name='C')
# 按行连接 DataFrame 和 Series
result_row = pd.concat([df, series], axis=0
# 按列连接 DataFrame 和 Series
result_col = pd.concat([df, series], axis=1)
print("按行连接结果:")
print(result_row)
print("\n按列连接结果:")
print(result_col)
’'''
按行连接结果:
A B C
0 1.0 4.0 NaN
1 2.0 5.0 NaN
2 3.0 6.0 NaN
0 NaN NaN 7.0
1 NaN NaN 8.0
2 NaN NaN 9.0
按列连接结果:
A B C
0 1 4 7
1 2 5 8
2 3 6 9
'''
5.3.5 删除数据行
您可以使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。使用的是 drop 函数
案例：
import pandas as pd
# 删除数据行
def sixteen():
data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
print("原数据：")
print(result)
print("drop 函数删除值：" )
result2 = result.drop('a')
print(result2)
'''
原数据：
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
drop 函数删除值：
one two
b 2.0 2
c 3.0 3
d NaN 4
'''
5.4 常用属性和方法
DataFrame 的属性和方法，与 Series 基本相同
| 名称 | 属性和方法描述 |
|---|---|
| T | 行和列转置。 |
| axes | 返回一个仅以行轴标签和列轴标签为成员的列表。 |
| dtypes | 返回每列数据的数据类型。 |
| empty | DataFrame中没有数据或者任意坐标轴的长度为0，则返回True。 |
| ndim | 轴的数量，也指数组的维数。 |
| shape | 返回一个元组，表示了 DataFrame 维度。 |
| size | DataFrame中的元素数量。 |
| values | 使用 numpy 数组表示 DataFrame 中的元素值。 |
| head() | 返回前 n 行数据。 |
| tail() | 返回后 n 行数据。 |
案例：
data = {"A": [1, 2, 3, 4], "B": [5, 6, 7, 8]}
df = pd.DataFrame(data=data, index=['a', 'b', 'c', 'd'])
print(df.T)
print(df.axes)
print(df.dtypes)
print(df.empty)
print(df.ndim)
print(df.shape)
print(df.size)
print(df.values)
print(df.head(3))
print(df.tail(3))
'''
a b c d
A 1 2 3 4
B 5 6 7 8
[Index(['a', 'b', 'c', 'd'], dtype='object'), Index(['A', 'B'], dtype='object')]
A int64
B int64
dtype: object
False
2
(4, 2)
8
[[1 5]
[2 6]
[3 7]
[4 8]]
A B
a 1 5
b 2 6
c 3 7
A B
b 2 6
c 3 7
d 4 8
'''
二、函数
1、常用的统计学函数
| 函数名称 | 描述说明 |
|---|---|
| count() | 统计某个非空值的数量 |
| sum() | 求和 |
| mean() | 求均值 |
| median() | 求中位数 |
| std() | 求标准差 |
| min() | 求最小值 |
| max() | 求最大值 |
| abs() | 求绝对值 |
| prod() | 求所有数值的乘积 |
案例：
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3, 4, 5],
'B': [10, 20, 30, 40, 50],
'C': [100, 200, 300, 400, 500]
}
df = pd.DataFrame(data)
#均值,每列分别计算
print('均值',df.mean(),'\n')
#中位数，每列分别计算
print('每列中位数',df.median(),'\n')
#标准差，每列分别计算
print('每列方差：',df.std(),'\n')
#方差，默认为标准差
print('每列标方差：',df.var(),'\n')
#最大最小值
print(f"max=\n{df.max()}\n min=\n{df.min()}")
#每列的总和
print('\n','每列的总和:\n',df.sum(),'\n')
#每列的非空值数量
print('每列的非空值数量:\n',df.count())
'''
均值 A 3.0
B 30.0
C 300.0
dtype: float64
每列中位数 A 3.0
B 30.0
C 300.0
dtype: float64
每列方差： A 1.581139
B 15.811388
C 158.113883
dtype: float64
每列标方差： A 2.5
B 250.0
C 25000.0
dtype: float64
max=
A 5
B 50
C 500
dtype: int64
min=
A 1
B 10
C 100
dtype: int64
每列的总和:
A 15
B 150
C 1500
dtype: int64
每列的非空值数量:
A 5
B 5
C 5
dtype: int64
'''
注意：numpy的方差默认为总体方差，pandas默认为样本方差
总体方差：
δ
2
=
1
N
∑
i
=
1
N
(
X
i
−
μ
)
2
\delta^2=\dfrac{1}{N}∑_{i=1}^N(X_i−μ)^2
δ2=N1i=1∑N(Xi−μ)2
样本方差：
δ
2
=
1
N
−
1
∑
i
=
1
N
(
X
i
−
X
‾
)
2
\delta^2=\dfrac{1}{N-1}∑_{i=1}^N(X_i−\overline X)^2
δ2=N−11i=1∑N(Xi−X)2
分母为n-1的样本方差的期望等于总体的方差，因此样本方差是总体方差的无偏估计。
2、重置索引
重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。
2.1 reindex()
reindex() 方法用于重新索引 DataFrame 或 Series 对象。重新索引意味着根据新的索引标签重新排列数据，并填充缺失值。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。
语法：
DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=np.nan, limit=None, tolerance=None)
参数：
- labels：
- 类型：数组或列表，默认为 None。
- 描述：新的索引标签。
- index：
- 类型：数组或列表，默认为 None。
- 描述：新的行索引标签。
- columns： 新的列索引标签
- 类型：数组或列表，默认为 None。
- 描述：新的列索引标签。
- axis：指定轴
- 类型：整数或字符串，默认为 None。
- 描述：指定重新索引的轴。0 或 ‘index’ 表示行，1 或 ‘columns’ 表示列。
- method：
- 类型：字符串，默认为 None。
- 描述：用于填充缺失值的方法。可选值包括 ‘ffill’（前向填充）、‘bfill’（后向填充）等。
- copy：
- 类型：布尔值，默认为 True。
- 描述：是否返回新的 DataFrame 或 Series。
- level：
- 类型：整数或级别名称，默认为 None。
- 描述：用于多级索引（MultiIndex），指定要重新索引的级别。
- fill_value：
- 类型：标量，默认为 np.nan。
- 描述：用于填充缺失值的值。
- limit：
- 类型：整数，默认为 None。
- 描述：指定连续填充的最大数量。
- tolerance：
- 类型：标量或字典，默认为 None。
- 描述：指定重新索引时的容差。
案例：
import pandas as pd
data={
'A': [1, 2, 3, 4,9,1],
'B': [5, 6, 7, 8,3,1],
'C': [9, 10, 11, 12,3,4],
'D': [3, 11,23,45,1,5],
'E': [9, 13,13,41,16,14]
}
#原DataFrame
# A B C D E
# a 1 5 9 3 9
# b 2 6 10 11 13
# c 3 7 11 23 13
# d 4 8 12 45 41
# e 9 3 3 1 16
# f 1 1 4 5 14
df = pd.DataFrame(data,index=['a','b','c','d','e','f'])
new_idx=['f','c','a','b','d','6','e']
## reindex 可以调整索引顺序，也可以添加存在的行或列，并且默认为空值
#当添加新的索引时，定义了ffill(前向填充)或bfill(后向填充)，需要指定检索的DataFrame是原来的还是修改之后的
#如果指定了修改之后的，这里以前向填充ffill为例：
#当程序运行时，如果有新添加的索引，程序会根据前向填充的规则，从新添加的索引 6 开始，检索本列中 6 上一个有效值的位置，
#读取这个索引，然后按照这个索引在原始DataFrame的行元素填充 6 这个索引位置，
df1=df.reindex(new_idx).loc[new_idx].ffill()
#
#
# A B C D E
# f 1.0 1.0 4.0 5.0 14.0
# c 3.0 7.0 11.0 23.0 13.0
# a 1.0 5.0 9.0 3.0 9.0
# b 2.0 6.0 10.0 11.0 13.0
# d 4.0 8.0 12.0 45.0 41.0
# 6 4.0 8.0 12.0 45.0 41.0
# e 9.0 3.0 3.0 1.0 16.0
#后向索引和前向索引的区别是检索时会查找 6 后面第一个有效值的索引，然后填充
df2=df.reindex(new_idx).loc[new_idx].bfill()
#
# A B C D E
# f 1.0 1.0 4.0 5.0 14.0
# c 3.0 7.0 11.0 23.0 13.0
# a 1.0 5.0 9.0 3.0 9.0
# b 2.0 6.0 10.0 11.0 13.0
# d 4.0 8.0 12.0 45.0 41.0
# 6 9.0 3.0 3.0 1.0 16.0
# e 9.0 3.0 3.0 1.0 16.0
#当不指定填充对象为新的DataFrame时，程序会默认为原来的DF，这时，无论新添加的索引位于新索引的那个位置，使用前向填充时都会变为None ，使用后向填充时会被填充为原来DataFrame的第0行
df3=df.reindex(new_idx,method='ffill')
# A B C D E
# f 1.0 1.0 4.0 5.0 14.0
# c 3.0 7.0 11.0 23.0 13.0
# a 1.0 5.0 9.0 3.0 9.0
# b 2.0 6.0 10.0 11.0 13.0
# d 4.0 8.0 12.0 45.0 41.0
# 6 NaN NaN NaN NaN NaN
# e 9.0 3.0 3.0 1.0 16.0
df4=df.reindex(new_idx,method='bfill')
# A B C D E
# f 1 1 4 5 14
# c 3 7 11 23 13
# a 1 5 9 3 9
# b 2 6 10 11 13
# d 4 8 12 45 41
# 6 1 5 9 3 9
# e 9 3 3 1 16
#使用 fill_value=‘ ’ 可以将新的索引行填充指定值
df5=df.reindex(new_idx,fill_value=0)
# A B C D E
# f 1 1 4 5 14
# c 3 7 11 23 13
# a 1 5 9 3 9
# b 2 6 10 11 13
# d 4 8 12 45 41
# 6 0 0 0 0 0
# e 9 3 3 1 16
print(df)
print('')
print(df1)
print("")
print(df2)
print('')
print(df3)
print('')
print(df4)
print('')
print(df5)
2.2 reindex_like
reindex_like 方法用于将一个 DataFrame 或 Series 的索引重新排列，使其与另一个 DataFrame 或 Series 的索引相匹配。如果在重新索引的过程中，新的索引与原始索引不完全匹配，那么不匹配的位置将会被填充为 NaN 值。
语法：
DataFrame.reindex_like(other, method=None, copy=True, limit=None, tolerance=None)
参数：
- other：
- 类型：DataFrame 或 Series。
- 描述：用于对齐索引和列的参考对象。
- method：
- 类型：字符串，默认为 None。
- 描述：用于填充缺失值的方法。可选值包括 ‘ffill’（前向填充）、‘bfill’（后向填充）等。
- copy：
- 类型：布尔值，默认为 True。
- 描述：是否返回新的 DataFrame 或 Series。
- limit：
- 类型：整数，默认为 None。
- 描述：指定连续填充的最大数量。
- tolerance：
- 类型：标量或字典，默认为 None。
- 描述：指定重新索引时的容差。
对齐索引：
import pandas as pd
# 创建两个示例 DataFrame
df1 = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
}, index=['a', 'b', 'c'])
df2 = pd.DataFrame({
'A': [7, 8, 9],
'B': [10, 11, 12]
}, index=['b', 'c', 'd'])
# 使用 reindex_like 对齐 df1 的行索引到 df2
# df1 的行索引被重新索引为 df2 的行索引，因此 df1 中不存在的行索引 'd' 对应的行填充了 NaN。
print(df1.reindex_like(df2))
# A B
# b 2.0 5.0
# c 3.0 6.0
# d NaN NaN
print('')
# 使用 reindex_like 对齐 df1 的列索引到 df2
df3 = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
}, index=['a', 'b', 'c'])
df4 = pd.DataFrame({
'B': [7, 8, 9],
'C': [10, 11, 12]
}, index=['a', 'b', 'c'])
print(df3.reindex_like(df4))
# B C
# a 4 NaN
# b 5 NaN
# # c 6 NaN
df4 = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
},index=['a', 'b', 'c'])
df5 = pd.DataFrame({
'A': [7, 8, 9],
'C': [10, 11, 12],
'D': [13, 14, 15]
},index=['a', 'e', 'f'])
print(df5.reindex_like(df4))
# A B
# a 7.0 NaN
# b NaN NaN
# c NaN NaN
3、遍历
对于 Series 而言，您可以把它当做一维数组进行遍历操作；而像 DataFrame 这种二维数据表结构，则类似于遍历 Python 字典
Series 可直接获取相应的 value，而 DataFrame 则会获取列标签
3.1 Series 遍历
遍历时可以使用几种方法：
items()，index属性,values属性,
import pandas as pd
#遍历方法
s=pd.Series([1,2,3,4,5],index=['a','b','c','d','e'])
#直接遍历
for i in s:
print(i)
#通过item方法获取index和value
for i,v in s.items():
print(f"index:{i},value:{v}")
#通过index获取
for i in s.index:
print(f"index:{i},value:{s[i]}")
#通过values遍历
for i in s.values:
print(f"value:{i}")
'''
1
2
3
4
5
index:a,value:1
index:b,value:2
index:c,value:3
index:d,value:4
index:e,value:5
index:a,value:1
index:b,value:2
index:c,value:3
index:d,value:4
index:e,value:5
value:1
value:2
value:3
value:4
value:5
'''
3.2 DataFrame 遍历
3.2.1 遍历行
- iterrrowa()方法遍历行（返回包含索引和行的迭代器）
- itertuples()方法遍历行 （返回包含行数据的元组），推荐使用，在速度和内存上都更高效
dataFrame_data = pd.DataFrame({
'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
})
#iterrrow()遍历行，返回一个包含索引和行的迭代器
df=dataFrame_data
for index,row in df.iterrows():
print(f"index:{index},\nrow:\n{row}\n")
print('----------------')
#itertuples()用于遍历行，同时返回一个包含行的命名元组
for row in df.itertuples():
print(row)
# 遍历每一行的元素值
for col in row._fields:
#getattr:获取row对象中的col属性
print(f"{col}, {getattr(row,col)}")
'''
index:a,
row:
one 1.0
two 1.0
Name: a, dtype: float64
index:b,
row:
one 2.0
two 2.0
Name: b, dtype: float64
index:c,
row:
one 3.0
two 3.0
Name: c, dtype: float64
index:d,
row:
one NaN
two 4.0
Name: d, dtype: float64
---------------------
Pandas(Index='a', one=1.0, two=1)
Index, a
one, 1.0
two, 1
Pandas(Index='b', one=2.0, two=2)
Index, b
one, 2.0
two, 2
Pandas(Index='c', one=3.0, two=3)
Index, c
one, 3.0
two, 3
Pandas(Index='d', one=nan, two=4)
Index, d
one, nan
two, 4
'''
3.2.2 遍历列
- item
- s() 方法遍历列，返回包含列名和列数据的迭代器
#items()方法用于遍历DataFrame的列，返回一个包含列名和列数据的迭代器
data=({
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]}
)
df=pd.DataFrame(data,index=['a','b','c'])
#items()遍历
for column_name,column_data in df.items():
print(f"name:{column_name}\ndata:\n{column_data}\n")
'''
name:A
data:
a 1
b 2
c 3
Name: A, dtype: int64
name:B
data:
a 4
b 5
c 6
Name: B, dtype: int64
name:C
data:
a 7
b 8
c 9
Name: C, dtype: int64
'''
3.2.3 使用loc()和iloc()方法按索引或位置遍历
import pandas as pd
# 创建一个简单的DataFrame
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}, index=['a', 'b', 'c'])
# 使用loc遍历DataFrame
for index, row in df.loc[:, 'A':'B'].iterrows():
print(index, row)
print('----------')
# 使用iloc遍历DataFrame
for index in range(len(df)):
print(df.iloc[index, :])
'''
a A 1
B 4
Name: a, dtype: int64
b A 2
B 5
Name: b, dtype: int64
c A 3
B 6
Name: c, dtype: int64
----------
A 1
B 4
Name: a, dtype: int64
A 2
B 5
Name: b, dtype: int64
A 3
B 6
Name: c, dtype: int64
'''
4、排序
4.1 sort_index 根据索引排序
语法：
DataFrame.sort_index(axis=0, ascending=True, inplace=False)
Series.sort_index(axis=0, ascending=True, inplace=False)
参数：
- axis：指定要排序的轴。默认为 0，表示按行索引排序。如果设置为 1，将按列索引排序。
- ascending：布尔值，指定是升序排序（True）还是降序排序（False）。
- inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。
4.2 sort_values() 根据一个或多个列的值排序
语法：
#排序方法
#sort_index 对索引排序
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
# 使用 items() 遍历列
for column_name, column_data in df.items():
print(f"{column_name}:\n{column_data}\n")
#sort_values用于根据一个或多个列的值对DateFrame进行排序
# 按列 'A' 排序
df_sorted = df.sort_values(by='A')
print(df_sorted)
# 按列 'A' 和 'B' 排序
df_sorted = df.sort_values(by=['A', 'B'])
print(df_sorted)
# 按列 'A' 降序排序
df_sorted = df.sort_values(by='A', ascending=False)
print(df_sorted)
参数：
- by：列的标签或列的标签列表。指定要排序的列。
- axis：指定沿着哪个轴排序。默认为 0，表示按行排序。如果设置为 1，将按列排序。
- ascending：布尔值或布尔值列表，指定是升序排序（True）还是降序排序（False）。可以为每个列指定不同的排序方向。
- inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。
- kind：排序算法。默认为 ‘quicksort’，也可以选择 ‘mergesort’ 或 ‘heapsort’。
- na_position：指定缺失值（NaN）的位置。可以是 ‘first’ 或 ‘last’。
4.3 案例
#排序方法
#sort_index 对索引排序
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
# 使用 items() 遍历列
for column_name, column_data in df.items():
print(f"{column_name}:\n{column_data}\n")
#sort_values用于根据一个或多个列的值对DateFrame进行排序
# 按列 'A' 排序
df_sorted = df.sort_values(by='A')
print(df_sorted)
# 按列 'A' 和 'B' 排序
df_sorted = df.sort_values(by=['A', 'B'])
print(df_sorted)
# 按列 'A' 降序排序
df_sorted = df.sort_values(by='A', ascending=False)
print(df_sorted)
'''
A:
a 1
b 2
c 3
Name: A, dtype: int64
B:
a 4
b 5
c 6
Name: B, dtype: int64
C:
a 7
b 8
c 9
Name: C, dtype: int64
A B C
a 1 4 7
b 2 5 8
c 3 6 9
A B C
a 1 4 7
b 2 5 8
c 3 6 9
A B C
c 3 6 9
b 2 5 8
a 1 4 7
'''
#按A升序排序，当A中出现想同值时，按B进行升序排列
data={'A': [1, 2,2,3,3,3, 5], 'B': [4, 5, 6,7,8,9,8], 'C': [1,2,3,4,5,7, 8]}
df = pd.DataFrame(data, index=['a', 'b', 'c','d','e','f','g'])
df_sorted = df.sort_values(by=['A', 'B'], ascending=[False,False])
print(df_sorted)
'''
A B C
g 5 8 8
f 3 9 7
e 3 8 5
d 3 7 4
c 2 6 3
b 2 5 2
a 1 4 1
'''
5、去重
5.1 drop_douplicates 删除重复行或Series中的元素
语法：
drop_duplicates(by=None, subset=None, keep='first', inplace=False)
Series.drop_duplicates(keep='first', inplace=False)
参数：
-
by：用于标识重复项的列名或列名列表。如果未指定，则使用所有列。
-
subset：与 by 类似，但用于指定列的子集。
-
keep：指定如何处理重复项。可以是：
- ‘first’：保留第一个出现的重复项（默认值）。
- ‘last’：保留最后一个出现的重复项。
- False：删除所有重复项。
-
inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的删除重复项后的对象。
5.2 例子
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 2, 2, 3, 2],
'B': [4, 5, 5, 4, 6, 5],
'C': [7, 8, 8, 7, 9, 8]
}
df = pd.DataFrame(data)
# 删除所有列的重复行，默认保留第一个出现的重复项
df_unique = df.drop_duplicates()
print(df_unique)
# 删除重复行，保留最后一个出现的重复项
df_unique = df.drop_duplicates(keep='last')
print(df_unique)
#删除所有重复项
df_unique = df.drop_duplicates(keep=False)
print(df_unique)
'''
A B C
0 1 4 7
1 2 5 8
3 2 4 7
4 3 6 9
A B C
0 1 4 7
3 2 4 7
4 3 6 9
5 2 5 8
A B C
0 1 4 7
3 2 4 7
4 3 6 9
'''
6、分组
6.1 groupby 分组
groupby 进行分组，分组之后可以直接进行运算
语法：
xxxxxxxxxx DataFrame.groupby(by, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)
参数：
- by：用于分组的列名或列名列表。
- axis：指定沿着哪个轴进行分组。默认为 0，表示按行分组。
- level：用于分组的 MultiIndex 的级别。
- as_index：布尔值，指定分组后索引是否保留。如果为 True，则分组列将成为结果的索引；如果为 False，则返回一个列包含分组信息的 DataFrame。
- sort：布尔值，指定在分组操作中是否对数据进行排序。默认为 True。
- group_keys：布尔值，指定是否在结果中添加组键。
- squeeze：布尔值，如果为 True，并且分组结果返回一个元素，则返回该元素而不是单列 DataFrame。
- observed：布尔值，如果为 True，则只考虑数据中出现的标签。
# groupby()分许
import pandas as pd
import numpy as np
# 创建一个示例 DataFrame
data = {
'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
'C': [1, 2, 3, 4, 5, 6, 7, 8],
'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)
#按列'A'分组
grouped1=df.groupby('A')
for name, group in grouped1:
print(name,'\n', group,'\n')
print('-----------------')
grouped2=df.groupby('B' )
for name, group in grouped2:
print(name,'\n', group,'\n')
#可以在分好组的内容内进行各种运算
#在grouped1内进行运算
# 在分组内根据C列求平均值
# transform用于在分组操作中对每个组内的数据进行转换，并将结果合并回原始 DataFrame。
mean = grouped1['C'].transform(lambda x: x.mean())
df['C_mean'] = mean
print(df)
# 在分组内根据C列求标准差
std1=grouped1['C'].transform('std')
df['C_std'] = std1
print(df)
#在分组内根据c列进行正态分布标准化
norm=grouped1['C'].transform(lambda x: (x-x.mean())/x.std())
df['C_norm'] = norm
print(df)
'''
bar
A B C D
1 bar one 2 20
3 bar three 4 40
5 bar two 6 60
foo
A B C D
0 foo one 1 10
2 foo two 3 30
4 foo two 5 50
6 foo one 7 70
7 foo three 8 80
-----------------
one
A B C D
0 foo one 1 10
1 bar one 2 20
6 foo one 7 70
three
A B C D
3 bar three 4 40
7 foo three 8 80
two
A B C D
2 foo two 3 30
4 foo two 5 50
5 bar two 6 60
A B C D C_mean
0 foo one 1 10 4.8
1 bar one 2 20 4.0
2 foo two 3 30 4.8
3 bar three 4 40 4.0
4 foo two 5 50 4.8
5 bar two 6 60 4.0
6 foo one 7 70 4.8
7 foo three 8 80 4.8
A B C D C_mean C_std
0 foo one 1 10 4.8 2.863564
1 bar one 2 20 4.0 2.000000
2 foo two 3 30 4.8 2.863564
3 bar three 4 40 4.0 2.000000
4 foo two 5 50 4.8 2.863564
5 bar two 6 60 4.0 2.000000
6 foo one 7 70 4.8 2.863564
7 foo three 8 80 4.8 2.863564
A B C D C_mean C_std C_norm
0 foo one 1 10 4.8 2.863564 -1.327018
1 bar one 2 20 4.0 2.000000 -1.000000
2 foo two 3 30 4.8 2.863564 -0.628587
3 bar three 4 40 4.0 2.000000 0.000000
4 foo two 5 50 4.8 2.863564 0.069843
5 bar two 6 60 4.0 2.000000 1.000000
6 foo one 7 70 4.8 2.863564 0.768273
7 foo three 8 80 4.8 2.863564 1.117488
'''
6.2 fillter 筛选数据
filter() 函数可以实现数据的筛选，该函数根据定义的条件过滤数据并返回一个新的数据集
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
'C': [1, 2, 3, 4, 5, 6, 7, 8],
'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)
# 按列 'A' 分组，并过滤掉列 'C' 的平均值小于 4 的组
filtered = df.groupby('A').filter(lambda x: x['C'].mean() >= 4)
print(filtered)
'''
A B C D
0 foo one 1 10
1 bar one 2 20
2 foo two 3 30
3 bar three 4 40
4 foo two 5 50
5 bar two 6 60
6 foo one 7 70
7 foo three 8 80
'''
7、合并
7.1 merge函数合并数据表
merge 函数用于将两个 DataFrame 对象根据一个或多个键进行合并，类似于 SQL 中的 JOIN 操作。这个方法非常适合用来基于某些共同字段将不同数据源的数据组合在一起，最后拼接成一个新的 DataFrame 数据
pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
参数：
-
left：左侧的 DataFrame 对象。
-
right：右侧的 DataFrame 对象。
-
how
：合并方式，可以是 ‘inner’、‘outer’、‘left’ 或 ‘right’。默认为 ‘inner’。
- ‘inner’：内连接，返回两个 DataFrame 共有的键。
- ‘outer’：外连接，返回两个 DataFrame 的所有键。
- ‘left’：左连接，返回左侧 DataFrame 的所有键，以及右侧 DataFrame 匹配的键。
- ‘right’：右连接，返回右侧 DataFrame 的所有键，以及左侧 DataFrame 匹配的键。
-
on：用于连接的列名。如果未指定，则使用两个 DataFrame 中相同的列名。
-
left_on 和 right_on：分别指定左侧和右侧 DataFrame 的连接列名。
-
left_index 和 right_index：布尔值，指定是否使用索引作为连接键。
-
sort：布尔值，指定是否在合并后对结果进行排序。
-
suffixes：一个元组，指定当列名冲突时，右侧和左侧 DataFrame 的后缀。
-
copy：布尔值，指定是否返回一个新的 DataFrame。如果为 False，则可能修改原始 DataFrame。
-
indicator：布尔值，如果为 True，则在结果中添加一个名为 __merge 的列，指示每行是如何合并的。
-
validate：验证合并是否符合特定的模式。
7.2 例子
内连接和外连接
import pandas as pd
# 创建两个DataFrame
df1 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
df2 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
# 执行内连接
result = pd.merge(df1, df2, on='key', how='inner')
#外连接
result2 = pd.merge( df1,df2,on='key', how='outer')
#左连接
result3 = pd.merge( df1,df2,on='key', how='left')
#右连接
result4 = pd.merge( df1,df2,on='key', how='right')
# 打印结果
print(result)
print('----------------')
print(result2)
print('----------------')
print(result3)
print('----------------')
print(result4))
'''
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 C2 D2
3 K3 A3 B3 C3 D3
----------------
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 C2 D2
3 K3 A3 B3 C3 D3
----------------
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 C2 D2
3 K3 A3 B3 C3 D3
----------------
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 C2 D2
3 K3 A3 B3 C3 D3
'''
8、时间函数
8.1 datetime()
datetime 模块提供了用于处理日期和时间的类。
from datetime import datetime
dt = datetime(2024, 5, 19, 16, 45, 30)
print(dt)
print(dt.date()) # 输出: 2024-05-19
print(dt.time()) # 输出: 16:45:00
8.2 Timestamp
Timestamp 是一个特殊的 datetime 类型，用于表示单个时间点
- 时间戳
时间戳是计算出来的一个数字，从1970年开始算，使用当前时间减去当时时间之后通过计算得到的一个相对时间1970-2038年
一般时间戳为十位时是秒级戳，是十三位时一般为毫秒级时间戳
import pandas as pd
# 从日期字符串创建
ts = pd.Timestamp('2024-05-19 16:45:00')
print(ts)
# 从时间戳创建
ts = pd.Timestamp(1652937700) # Unix 时间戳
print(ts)
'''
2024-05-19 16:45:00
1970-01-01 00:00:01.652937700
'''
pd.to_datetime() 方法转换字符串或其他格式的日期
pd.to_datetime() 方法用于将字符串或其他格式的日期转换为 Pandas 的 Datetime 对象。
import pandas as pd
# 将字符串转换为 Datetime 对象
date_str = '2023-10-01'
date_obj = pd.to_datetime(date_str)
print(date_obj)
# 获取当前时间
print('当前时间：')
print(datetime.now())
'''
2023-10-01 00:00:00
当前时间：
2024-12-30 19:01:12.335103
'''
8.4 date_range()生成时间索引
date_range() 函数用于生成一个固定频率的日期时间索引（DatetimeIndex）。这个函数非常灵活，可以用于生成各种时间序列数据。
语法
pandas.date_range(start=None, end=None, periods=None, freq=None, tz=None, normalize=False, name=None, closed=None, **kwargs)
参数：
- start：
- 类型：字符串或日期时间对象，默认为 None。
- 描述：起始日期时间。
- end：
- 类型：字符串或日期时间对象，默认为 None。
- 描述：结束日期时间。
- periods：
- 类型：整数，默认为 None。
- 描述：生成的日期时间索引的数量。
- freq：
- 类型：字符串或日期偏移对象，默认为 None。
- 描述：时间频率。常见的频率包括 ‘D’（天）、‘H’（小时）、‘T’ 或 ‘min’（分钟）、‘S’（秒）等。
- tz：
- 类型：字符串或时区对象，默认为 None。
- 描述：指定时区。
- normalize：
- 类型：布尔值，默认为 False。
- 描述：是否将时间归一化到午夜。
- name：
- 类型：字符串，默认为 None。
- 描述：生成的日期时间索引的名称。
- closed：
- 类型：字符串，默认为 None。
- 描述：指定区间是否包含起始或结束日期时间。可选值为 ‘left’、‘right’ 或 None。
import pandas as pd
from datetime import datetime as dt
#生成24.12.25到现在的时间索引，按天
date_index1=pd.date_range(start='2024-12-25',end=dt.now(),freq='D')
print(date_index1)
#生成某天的时间索引，24小时制
date_index=pd.date_range(start='2024-12-25',periods=24,freq='h')
print(date_index)
'''
DatetimeIndex(['2024-12-25', '2024-12-26', '2024-12-27', '2024-12-28',
'2024-12-29', '2024-12-30'],
dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2024-12-30 14:05:14.726492', '2024-12-30 15:05:14.726492',
'2024-12-30 16:05:14.726492', '2024-12-30 17:05:14.726492',
'2024-12-30 18:05:14.726492', '2024-12-30 19:05:14.726492',
'2024-12-30 20:05:14.726492', '2024-12-30 21:05:14.726492',
'2024-12-30 22:05:14.726492', '2024-12-30 23:05:14.726492',
'2024-12-31 00:05:14.726492', '2024-12-31 01:05:14.726492',
'2024-12-31 02:05:14.726492', '2024-12-31 03:05:14.726492',
'2024-12-31 04:05:14.726492', '2024-12-31 05:05:14.726492',
'2024-12-31 06:05:14.726492', '2024-12-31 07:05:14.726492',
'2024-12-31 08:05:14.726492', '2024-12-31 09:05:14.726492',
'2024-12-31 10:05:14.726492', '2024-12-31 11:05:14.726492',
'2024-12-31 12:05:14.726492', '2024-12-31 13:05:14.726492'],
dtype='datetime64[ns]', freq='h')
'''
8.5 时间差 Timedelta
#时间差加减
import pandas as pd
from datetime import datetime as dt
td1=pd.Timedelta('1 days 2 hours 30 minutes')
ts1=pd.Timestamp('2024-01-01')
new_ts=ts1+td1
print(new_ts)
'''
2024-01-02 02:30:00
'''
8.6 时间日期格式化 strftime、strptime
strftime 用于将日期时间对象转换为指定格式的字符串，
而 strptime 用于将字符串解析为日期时间对象。
#strftime将日期时间对象转化位指定格式的字符串，strptime将字符串解析位日期时间对象
date_obj=datetime(2023,10,1,14,30,45)
date_str=date_obj.strftime('%Y-%m-%d %H:%M:%S')
print(date_str)
#将字符串解析为日期时间对象
date_obj1=datetime.strptime(date_str,'%Y-%m-%d %H:%M:%S')
print(date_obj1)
'''
2023-10-01 14:30:45
2023-10-01 14:30:45
'''
8.6.1 时间日期符号
时间日期符号：
符号 说明
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（0000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地英文缩写星期名称
%A 本地英文完整星期名称
%b 本地缩写英文的月份名称
%B 本地完整英文的月份名称
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%U 一年中的星期数（00-53）星期天为星期的开始
%j 年内的一天（001-366）
%c 本地相应的日期表示和时间表示
9、随机抽样 sample
用于随机抽取DataFrame中的行或列，可以选择是否抽取重复元素，也可以选择抽取是否放回。
语法：
DataFrame.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)
参数：
- n：要抽取的行数
- frac：抽取的比例，比如 frac=0.5，代表抽取总体数据的50%
- replace：布尔值参数，表示是否以有放回抽样的方式进行选择，默认为 False，取出数据后不再放回
- weights：可选参数，代表每个样本的权重值，参数值是字符串或者数组
- random_state：可选参数，控制随机状态，默认为 None，表示随机数据不会重复；若为 1 表示会取得重复数据
- axis：表示在哪个方向上抽取数据(axis=1 表示列/axis=0 表示行)
import pandas as pd
df = pd.DataFrame({
"company": ['百度', '阿里', '腾讯'],
"salary": [43000, 24000, 40000],
"age": [25, 35, 49]
})
print('随机选择2行：')
print(df.sample(n=2, axis=0))
print('随机选择2行,有放回：')
print(df.sample(n=2, axis=0,replace=True))
print('随机选择一列：')
print(df.sample(n=1, axis=1))
print('总体的50%：')
print(df.sample(axis=0, frac=0.5))
'''
随机选择2行：
company salary age
2 腾讯 40000 49
1 阿里 24000 35
随机选择2行,有放回：
company salary age
1 阿里 24000 35
1 阿里 24000 35
随机选择一列：
company
0 百度
1 阿里
2 腾讯
总体的50%：
company salary age
0 百度 43000 25
2 腾讯 40000 49
'''
10、空值处理
10.1 空值处理 isnull() /notnull 返回布尔值
-
isnull()用于检测 DataFrame 或 Series 中的空值，返回一个布尔值的 DataFrame 或 Series。
-
notnull()用于检测 DataFrame 或 Series 中的非空值，返回一个布尔值的 DataFrame 或 Series。
import pandas as pd
import numpy as np
# 创建一个包含空值的示例 DataFrame
data = {
'A': [1, 2, np.nan, 4],
'B': [5, np.nan, np.nan, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
# 检测空值
is_null = df.isnull()
print(is_null)
# 检测非空值
not_null = df.notnull()
print(not_null)
'''
A B C
0 False False False
1 False True False
2 True True False
3 False False False
A B C
0 True True True
1 True False True
2 False False True
3 True True True
'''
fillna() 填充空值
# 创建一个包含空值的示例 DataFrame
data = {
'A': [1, 2, np.nan, 4],
'B': [5, np.nan, np.nan, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
# 用 0 填充空值
df_filled = df.fillna(0)
print(df_filled)
'''
A B C
0 1.0 5.0 9
1 2.0 0.0 10
2 0.0 0.0 11
3 4.0 8.0 12
'''
10.3 dorpna()删除空值
#填充空值,删除空值
data = {
'A': [1, 2, np.nan, 4],
'B': [5, np.nan, np.nan, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
df_filled=df.fillna(6)
print(df_filled)
#drop删除空值
#参数
#how: ’any‘， ‘all’
#删除包含空值的列
df_droped=df.dropna(axis=1,how='any')
print(df_droped)
#只删除整行或整列都为空值的才删除
df_droped2=df.dropna(axis=1,how='all')
print(df_droped2)
'''
A B C
0 1.0 5.0 9
1 2.0 6.0 10
2 6.0 6.0 11
3 4.0 8.0 12
C
0 9
1 10
2 11
3 12
A B C
0 1.0 5.0 9
1 2.0 NaN 10
2 NaN NaN 11
3 4.0 8.0 12
'''
三、读取文件
1.1 读取csv文件
CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）；
CSV 是一种通用的、相对简单的文件格式，介于excel和文本文档之间，能够被两者多读写。
1.1.1 to_csv() 存储为csv文件
- to_csv() 方法将 DataFrame 存储为 csv 文件
- 如果存储路径不写，会将文件存储在程序文件的相对路径内，于程序文件同级
1.1.2read_csv() 读取csv文件数据
read_csv() 表示从 CSV 文件中读取数据，并创建 DataFrame 对象。
1.1.3 例子
#csvs是一个介于文本文档和excel文本之间的一种文本，能够以以上两种形式打开
#默认不写，存储在文件的相对路径上，即这个程序的路径
import pandas as pd
data = {
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)
# 确保路径字符串被正确处理，并且包含.csv扩展名
csv_file_path = r'D:\2\12.30\文件\data.csv'
df.to_csv(csv_file_path, index=False)
df3=pd.read_csv(r'D:\2\12.30\文件\data.csv')
print(df3)
'''
Name Age City
0 Alice 25 New York
1 Bob 30 Los Angeles
2 Charlie 35 Chicago
'''
1.2 读取Excel 文件
Excel操作需要安装第三方库
pip install openpyxl
1.2.1 read_excel() 读取excel中的表格
read_excel() 读取 Excel 表格中的数据。
语法：
pd.read_excel(io, sheet_name=0, header=0, names=None, index_col=None,
usecols=None, squeeze=False,dtype=None, engine=None,
converters=None, true_values=None, false_values=None,
skiprows=None, nrows=None, na_values=None, parse_dates=False,
date_parser=None, thousands=None, comment=None, skipfooter=0,
convert_float=True, **kwds)
参数说明：
| 参数名称 | 说明 |
|---|---|
| io | 表示 Excel 文件的存储路径。 |
| sheet_name | 要读取的工作表名称。 |
| header | 指定作为列名的行，默认0，即取第一行的值为列名；若数据不包含列名，则设定 header = None。若将其设置 为 header=2，则表示将前两行作为多重索引。 |
| names | 一般适用于Excel缺少列名，或者需要重新定义列名的情况；names的长度必须等于Excel表格列的长度，否则会报错。 |
| index_col | 用做行索引的列，可以是工作表的列名称，如 index_col = ‘列名’，也可以是整数或者列表。 |
| usecols | int或list类型，默认为None，表示需要读取所有列。 |
| squeeze | boolean，默认为False，如果解析的数据只包含一列，则返回一个Series。 |
| converters | 规定每一列的数据类型。 |
| skiprows | 接受一个列表，表示跳过指定行数的数据，从头部第一行开始。 |
| nrows | 需要读取的行数。 |
| skipfooter | 接受一个列表，省略指定行数的数据，从尾部最后一行开始。 |
import pandas as pd
# 读取 Excel 文件
df = pd.read_excel('data.xlsx')
print(df)
# 读取特定工作表
df = pd.read_excel('data.xlsx', sheet_name='Sheet1')
print(df)
1.2.2 to_eccel() xieru1Excel文件
to_excel() 函数可以将 DataFrame 中的数据写入到 Excel 文件。
- 如果想要把单个对象写入 Excel 文件，那么必须指定目标文件名；
- 如果想要写入到多张工作表中，则需要创建一个带有目标文件名的 ExcelWriter 对象，并通过 sheet_name 参数依次指定工作表的名称。
语法：
DataFrame.to_excel(excel_writer, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True, encoding=None, inf_rep='inf', verbose=True, freeze_panes=None)
参数说明：
| 参数名称 | 描述说明 |
|---|---|
| excel_wirter | 文件路径或者 ExcelWrite 对象。 |
| sheet_name | 指定要写入数据的工作表名称。 |
| na_rep | 缺失值的表示形式。 |
| float_format | 它是一个可选参数，用于格式化浮点数字符串。 |
| columns | 指要写入的列。 |
| header | 写出每一列的名称，如果给出的是字符串列表，则表示列的别名。 |
| index | 表示要写入的索引。 |
| index_label | 引用索引列的列标签。如果未指定，并且 hearder 和 index 均为为 True，则使用索引名称。如果 DataFrame 使用 MultiIndex，则需要给出一个序列。 |
| startrow | 初始写入的行位置，默认值0。表示引用左上角的行单元格来储存 DataFrame。 |
| startcol | 初始写入的列位置，默认值0。表示引用左上角的列单元格来储存 DataFrame。 |
| engine | 它是一个可选参数，用于指定要使用的引擎，可以是 openpyxl 或 xlsxwriter。 |
import pandas as pd
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data)
# 保存 DataFrame 为 Excel 文件
df.to_excel('data.xlsx')
# 保存 DataFrame 为 Excel 文件，不保存索引
df.to_excel('data.xlsx', index=False)
五、绘图
Pandas 在数据分析、数据可视化方面有着较为广泛的应用，Pandas 对 Matplotlib 绘图软件包的基础上单独封装了一个plot()接口，通过调用该接口可以实现常用的绘图操作；
Pandas 之所以能够实现了数据可视化，主要利用了 Matplotlib 库的 plot() 方法，它对 plot() 方法做了简单的封装，因此您可以直接调用该接口；
只用 pandas 绘制图片可能可以编译，但是不会显示图片，需要使用 matplotlib 库，调用 show() 方法显示图形。
1.1 例子
import pandas as pd
import matplotlib.pyplot as plt
# 创建一个示例 DataFrame
data = {
'A': [1, 2, 3, 4, 5],
'B': [10, 20, 25, 30, 40]
}
df = pd.DataFrame(data)
# 创建一个图形
fig, axs = plt.subplots(2, 2) # 创建2x2的子图布局
# 绘制折线图
df.plot(kind='line', ax=axs[0, 0])
axs[0, 0].set_title('Line Plot')
# 绘制柱状图
df.plot(kind='bar', ax=axs[0, 1])
axs[0, 1].set_title('Bar Plot')
# 绘制直方图
df['A'].plot(kind='hist', ax=axs[1, 0])
axs[1, 0].set_title('Histogram')
# 绘制散点图
df.plot(kind='scatter', x='A', y='B', ax=axs[1, 1])
axs[1, 1].set_title('Scatter Plot')
# 调整子图间距
plt.tight_layout()
# 显示图形
plt.show()
# 创建一个示例 Series
data = {
'A': 10,
'B': 20,
'C': 30,
'D': 40
}
series = pd.Series(data)
# 绘制饼图
series.plot(kind='pie', autopct='%1.1f%%')
# 显示图表
plt.show()
扫一扫
1205
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
