Python Pandas库学习心得

X天地不仁

已于 2025-01-09 15:42:58 修改

阅读量672

点赞数 16

文章标签： python pandas 开发语言

于 2024-12-30 00:39:54 首次发布

本文链接：https://blog.csdn.net/m0_62791338/article/details/144812515

版权

一、基础

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)

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 对象

import pandas as pd

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 数据

直接调用[index]，便可以访问对应的数据

import pandas as pd

s1 = pd.Series({'name':'Vincent','age':18,'gender':'male'})
print(s1)
print(s1['name'])

"""
name      Vincent
age            18
gender       male
dtype: object
Vincent

"""

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)
    
    
six()

4.4 Series 常用方法

4.4.1 head() 和 tail()

查看 Series 的某一部分数据，使用 head() 或者 tail() 方法。其中 head() 返回前 n 行数据，默认显示前 5 行数据，tail() 返回后 n 行数据，默认为后 5 行

import pandas as pd

s1 = pd.Series(['one','two','three','four','five','six','seven','eight','nine'])

print(s1.head())

print(s1.tail())

"""
0      one
1      two
2    three
3     four
4     five
dtype: object
4     five
5      six
6    seven
7    eight
8     nine
dtype: object
"""

4.4.2 isnull() 和 nonull()

isnull() 和 nonull() 用于检测 Series、DataFrame 中的缺失值。所谓缺失值，顾名思义就是值不存在、丢失、缺少

isnull()：如果为值不存在或者缺失，则返回 True
notnull()：如果值不存在或者缺失，则返回 False

import pandas as pd

s1 = pd.Series(['one','two','three','four',None,'six','seven','eight','nine'])

print(s1.isnull())

"""
0    False
1    False
2    False
3    False
4     True
5    False
6    False
7    False
8    False
dtype: bool
"""

5、DataFrame

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：

标签是列名。

值是该行的所有列数据。

5.1 创建 DataFrame 对象

创建 DataFrame 对象的方式：

列表
字典
Series
Numpy ndarrays
另一个 DataFrame

5.1.1 创建 DataFrame 空对象

import pandas as pd

# 创建 DataFrame 空对象

result = pd.DataFrame()
print(result)

5.1.2 列表创建 DataFrame 对象

import pandas as pd

# 列表创建 DataFrame 对象

data = ['小明','小红','小紫']
column = ['name']
result = pd.DataFrame(data=data,columns=column)
print(result)

5.1.2 列表嵌套列表创建 DataFrame 对象

import pandas as pd

# 列表创建 DataFrame 对象

data = [['小米', 18], ['小红', 19], ['小紫', 20]]
result = pd.DataFrame(data=data,columns=['name','age'])
print(result)

"""
  name  age
0   小米   18
1   小红   19
2   小紫   20

"""

5.1.3 列表嵌套字典创建 DataFrame 对象

如果其中某个元素值缺失，也就是字典的 key 无法找到对应的 value，将使用 NaN 代替。

import pandas as pd


data = [{'name': "张三", 'age': 18}, {'name': "小红", 'gender': "男", 'age': 19}]
result = pd.DataFrame(data=data)
print(result)


"""
  name  age gender
0   张三   18    NaN
1   小红   19      男

"""

5.1.4 字典嵌套列表创建 DataFrame 对象

import pandas as pd

data = {'name':['a','b','c'],'age':[10,20,30]}
df = pd.DataFrame(data)
print(df)

"""
  name  age
0    a   10
1    b   20
2    c   30
"""

5.1.5 Series 创建 DataFrame 对象

第一列Series比第二列少一个元素，则以NaN填充，数据类型转换为float

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)

seven()

"""
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4
"""

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,end = '\n\n')
    print(result['one'])

eight()

"""
   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 添加数据

直接添加，assign方法，Series添加，insert插入

①添加新列，直接赋值添加

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

"""

②通过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)

③通过Series添加新列

import pandas as pd

# 添加数据
def nine():
    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)

nine()

"""
使用 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
"""

④在指定的位置插入新列

使用insert方法在指定位置插入新列，参数：

loc: 插入位置的列索引。

column: 新列的名称。

value: 要插入的 Series。

import pandas as pd

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(loc=1, column='D',value=[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.3 行索引操作

5.3.1 loc 选取数据

语法：

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'])

# 使用 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    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(df.iloc[0:2])  # 选择第 0 到 1 行的数据
print(df.iloc[0, 1])  # 选择第 0 行，第 1 列的元素
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
"""

5.3.3 切片多行选取

切片区别于iloc，[0:2]，只取了0，1。取不到2

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)

5.3.4 添加数据行

①使用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)

②concat 拼接

按行连接（垂直堆叠）

# 创建两个示例 DataFrame
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]
})

# 按行连接 df1 和 df2
result = pd.concat([df1, df2], axis=0)

print(result)

"""  
   A   B
0  1   4
1  2   5
2  3   6
0  7  10
1  8  11
2  9  12
"""

按列连接（水平堆叠）

# 创建两个示例 DataFrame
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})

df2 = pd.DataFrame({
    'C': [7, 8, 9],
    'D': [10, 11, 12]
})

# 按列连接 df1 和 df2
result = pd.concat([df1, df2], axis=1)

print(result)

"""
   A  B  C   D
0  1  4  7  10
1  2  5  8  11
2  3  6  9  12
"""

③使用 join='inner'，按行合并

import pandas as pd

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)

"""
   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
"""

④Dataframe和Series连接

axis=0，在垂直方向上拼接。 axis=1，在水平方向上拼接。

# 创建一个示例 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 删除数据行

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)
sixteen()
"""
原数据：
   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 行数据。

import pandas as pd
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()	求所有数值的乘积

2、重置索引

重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

2.1 reindex

reindex() 方法用于重新索引 DataFrame 或 Series 对象。重新索引意味着根据新的索引标签重新排列数据，并填充缺失值。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

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'])

# 重新索引行
new_index = ['a', 'b', 'c', 'd']
df_reindexed = df.reindex(new_index)
print(df_reindexed)

# 重新索引列
new_columns = ['A', 'B', 'C', 'D']
df_reindexed = df.reindex(columns=new_columns)
print(df_reindexed)

# 重新索引行，并使用前向填充
# 新的行索引 ['a', 'b', 'c', 'd'] 包含了原索引中不存在的标签 'd'，使用 method='ffill' 进行前向填充，因此 'd' 对应的行填充了前一行的值。
new_index = ['a', 'b', 'c', 'd']
df_reindexed = df.reindex(new_index, method='ffill')
print(df_reindexed)

# 重新索引行，并使用指定的值填充缺失值
new_index = ['a', 'b', 'c', 'd']
df_reindexed = df.reindex(new_index, fill_value=0)
print(df_reindexed)

"""
     A    B    C
a  1.0  4.0  7.0
b  2.0  5.0  8.0
c  3.0  6.0  9.0
d  NaN  NaN  NaN
   A  B  C   D
a  1  4  7 NaN
b  2  5  8 NaN
c  3  6  9 NaN
   A  B  C
a  1  4  7
b  2  5  8
c  3  6  9
d  3  6  9
   A  B  C
a  1  4  7
b  2  5  8
c  3  6  9
d  0  0  0
"""

2.2 reindex_like

reindex_like 方法用于将一个 DataFrame 或 Series 的索引重新排列，使其与另一个 DataFrame 或 Series 的索引相匹配。如果在重新索引的过程中，新的索引与原始索引不完全匹配，那么不匹配的位置将会被填充为 NaN 值。

reindex和reindex_like区别：前者要引用具体的索引，后者是两个DataFrame 或 Series之间的关系。

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'])

df3 = df1.reindex_like(df2)
print(df3)

# 创建两个示例 DataFrame
'''
行标签相同，对齐列索引
'''
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
}, index=['a', 'b', 'c'])

df2 = pd.DataFrame({
    'B': [7, 8, 9],
    'C': [10, 11, 12]
}, index=['a', 'b', 'c'])

# 使用 reindex_like 对齐 df1 的列索引到 df2
df4 = df1.reindex_like(df2)

print(df4)

'''
df的行和列标签均不同，则作行和列的复制
'''
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
}, index=['a', 'b', 'c'])

df2 = pd.DataFrame({
    'B': [7, 8, 9],
    'C': [10, 11, 12]
}, index=['b', 'c', 'd'])
#依据df2的索引，df1给出匹配索引的元素
df5 = df1.reindex_like(df2)
print(df5)

"""
     A    B
b  2.0  5.0
c  3.0  6.0
d  NaN  NaN
   B   C
a  4 NaN
b  5 NaN
c  6 NaN
     B   C
b  5.0 NaN
c  6.0 NaN
d  NaN NaN
"""

3、遍历

对于 Series 而言，您可以把它当做一维数组进行遍历操作；而像 DataFrame 这种二维数据表结构，则类似于遍历 Python 字典

Series 可直接获取相应的 value，而 DataFrame 则会获取列标签

3.1 Series遍历

①使用 items()

import pandas as pd

# 创建一个示例 Series
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
for index, value in series.items():
    print(f"Index: {index}, Value: {value}")

②使用index 属性

import pandas as pd

# 创建一个示例 Series
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])

# 遍历索引
for index in series.index:
    print(f"Index: {index}, Value: {series[index]}")

③使用values 属性

import pandas as pd

# 创建一个示例 Series
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])

# 遍历值
for value in series.values:
    print(f"Value: {value}")

3.2 DataFrame 遍历

直接遍历，得到的是列标签

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'])
})
# 遍历dataframe得到的是列标签
print('DataFrame：')
for item in dataFrame_data:
    print(item, end=' ')

遍历行

iterrows() 方法用于遍历 DataFrame 的行，返回一个包含索引和行的迭代器。

import pandas as pd
def pd_dict_list():
    "直接遍历，获得的是列标签"
    df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
    for i in df:
        print(i)

    '通过iterrows，得到两个对象：index，row行数据（Series类型）'
    for index,row in df.iterrows():
        print(f'index:{index},value: {row}')
        for v in row:
            print(v)

    'itertuples（带行标签和数据的元组）。如需忽略行标签，index = False'
    for row in df.itertuples(index=False):
        print(row)
        for v in row:
            print(v)

            
    '按列遍历，items()：得到两个对象，列名和列数据（Series对象）'
    for name,item in df.items():
        print(f'name:{name},item:{item}')

    for index in df.index:
        for col in df.columns:
            print(f'index:{index},value:{df.loc[index,col]}')

pd_dict_list()

4、排序

4.1 sort_index

根据索引进行排序

import pandas as pd

df = pd.DataFrame({'A':[1,2,3],'B':[4,5,6]},index=['b','a','c'])
df1 = df.sort_index(ascending = False)
print(df1)

4.2 sort_values

根据列的值排序

语法：

DataFrame.sort_values(by, axis=0, ascending=True, 
inplace=False, kind='quicksort', na_position='last')

参数：

by：列的标签或列的标签列表。指定要排序的列。

axis：指定沿着哪个轴排序。默认为 0，表示按行排序。如果设置为 1，将按列排序。

ascending：布尔值或布尔值列表，指定是升序排序（True）还是降序排序（False）。可以为每个列指定不同的排序方向。

inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。

kind：排序算法。默认为 'quicksort'，也可以选择 'mergesort' 或 'heapsort'。

na_position：指定缺失值（NaN）的位置。可以是 'first' 或 'last'。

import pandas as pd

# sort_values()：按列排序，可以按一列，也可以按多列排序
data = {
    'A': [3, 2, 1],
    'B': [6, 5, 4],
    'C': [9, 8, 7]
}
df = pd.DataFrame(data, index=['b', 'c', 'a'])

# 按列 'A' 排序，按一列
df_sorted = df.sort_values(by='A')
print(df_sorted)

# 按列 'Age' 和 'Score' 排序，按多列
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Age': [25, 30, 25, 35, 30],
    'Score': [85, 90, 80, 95, 88]
})
df_sorted = df.sort_values(by=['Age', 'Score'])
print(df_sorted)


# 按列 'Age' 和 'Score' 排序，先按A列降序排序，如果A列中值相同则按B列升序排序
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Age': [25, 30, 25, 35, 30],
    'Score': [85, 90, 80, 95, 88]
})
df_sorted = df.sort_values(by=['Age', 'Score'], ascending=[False, True])
print(df_sorted)


"""
   A  B  C
a  1  4  7
c  2  5  8
b  3  6  9
      Name  Age  Score
2  Charlie   25     80
0    Alice   25     85
4      Eve   30     88
1      Bob   30     90
3    David   35     95
      Name  Age  Score
3    David   35     95
4      Eve   30     88
1      Bob   30     90
2  Charlie   25     80
0    Alice   25     85
"""

5、去重

drop_duplicates 方法用于删除 DataFrame 或 Series 中的重复行或元素。

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 2, 3],
    'B': [4, 5, 5, 6],
    'C': [7, 8, 8, 9]
}
df = pd.DataFrame(data)

# 删除所有列的重复行，默认保留第一个出现的重复项
df_unique = df.drop_duplicates()
print(df_unique)

# 删除重复行，保留最后一个出现的重复项
df_unique = df.drop_duplicates(keep='last')
print(df_unique)

"""
   A  B  C
0  1  4  7
1  2  5  8
3  3  6  9
   A  B  C
0  1  4  7
2  2  5  8
3  3  6  9

"""

6、分组

6.1 groupby

groupby 方法用于对数据进行分组操作，这是数据分析中非常常见的一个步骤。通过 groupby，你可以将数据集按照某个列（或多个列）的值分组，然后对每个组应用聚合函数，比如求和、平均值、最大值等。

import pandas as pd

def pd_groupby():
    # 创建一个示例 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' 分组
    groupbyed = df.groupby('A')
    print(list(groupbyed))

    # 在分组内根据C列求平均值
    mean = groupbyed['C'].mean()
    print(mean)

    # 在分组内根据C列求平均值
    # transform用于在分组操作中对每个组内的数据进行转换，并将结果合并回原始 DataFrame。
    c_mean = groupbyed['C'].transform(lambda x: x.mean())
    df['c_mean'] = c_mean
    print(df)



pd_groupby()
"""
[('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)]
A
bar    4.0
foo    4.8
Name: C, dtype: float64
     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
"""

6.2 filter

通过 filter() 函数可以实现数据的筛选，该函数根据定义的条件过滤数据并返回一个新的数据集

import pandas as pd

def pd_groupby_filter():
    # 创建一个示例 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)


    df1 = df.groupby('A').filter(lambda x: x['C'].mean() > 4)
    print(df1)

pd_groupby_filter()

"""
     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
"""

7、合并 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：验证合并是否符合特定的模式。

import pandas as pd

def pd_merge():
    # 创建两个示例 DataFrame
    left = pd.DataFrame({
        'key': ['K0', 'K1', 'K2', 'K3'],
        'A': ['A0', 'A1', 'A2', 'A3'],
        'B': ['B0', 'B1', 'B2', 'B3']
    })

    right = pd.DataFrame({
        'key': ['K0', 'K1', 'K2', 'K4'],
        'C': ['C0', 'C1', 'C2', 'C3'],
        'D': ['D0', 'D1', 'D2', 'D3']
    })

    result = pd.merge(left, right, on='key')
    print(result)

    # on是连接的参数，how是连接的方式
    result1 = pd.merge(left, right, on='key', how='left')
    print(result1)

pd_merge()



"""
  key   A   B   C   D
0  K0  A0  B0  C0  D0
1  K1  A1  B1  C1  D1
2  K2  A2  B2  C2  D2
  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  NaN  NaN
"""

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 类型，用于表示单个时间点。它是 pandas 时间序列功能的核心组件，提供了丰富的方法和属性来处理日期和时间数据。

8.3 日期解析

pd.to_datetime() 方法用于将字符串或其他格式的日期转换为 Pandas 的 Datetime 对象。

8.4 date_range

date_range() 函数用于生成一个固定频率的日期时间索引（DatetimeIndex）。这个函数非常灵活，可以用于生成各种时间序列数据。

import pandas as pd
import time
def pd_time():
    t = pd.Timestamp('2024-12-30 13:50:10')
    print(t)

    t1 = pd.Timestamp(1735538116687.3612,unit='ms',tz='Asia/Shanghai')
    print(t1)

    s = '2024-12-30 13:50:10'
    t2 = pd.to_datetime(s)
    print(t2)

    t3 = pd.date_range('2024-12-01','2024-12-30',freq='h')
    print(t3)
pd_time()

"""
2024-12-30 13:50:10
2024-12-30 13:55:16.687361084+08:00
2024-12-30 13:50:10
DatetimeIndex(['2024-12-01 00:00:00', '2024-12-01 01:00:00',
               '2024-12-01 02:00:00', '2024-12-01 03:00:00',
               '2024-12-01 04:00:00', '2024-12-01 05:00:00',
               '2024-12-01 06:00:00', '2024-12-01 07:00:00',
               '2024-12-01 08:00:00', '2024-12-01 09:00:00',
               ...
               '2024-12-29 15:00:00', '2024-12-29 16:00:00',
               '2024-12-29 17:00:00', '2024-12-29 18:00:00',
               '2024-12-29 19:00:00', '2024-12-29 20:00:00',
               '2024-12-29 21:00:00', '2024-12-29 22:00:00',
               '2024-12-29 23:00:00', '2024-12-30 00:00:00'],
              dtype='datetime64[ns]', length=697, freq='h')
"""

上述代码包含了8.2-8.4的示例

9、随机抽样

语法：

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 numpy as np
import pandas as pd

def pd_sample():
    df = pd.DataFrame({
      "company":['百度','阿里','腾讯'],
        "salary":[10000,20000,30000],
        "age":[25,44,30]
    })

    df1 = df.sample(2,axis=0)
    print(df1)
    df2 = df.sample(1,axis=1)
    print(df2)

pd_sample()


"""
  company  salary  age
1      阿里   20000   44
2      腾讯   30000   30
   salary
0   10000
1   20000
2   30000
"""

10、空值处理

10.1 检测空值

isnull()用于检测 DataFrame 或 Series 中的空值，返回一个布尔值的 DataFrame 或 Series。

notnull()用于检测 DataFrame 或 Series 中的非空值，返回一个布尔值的 DataFrame 或 Series。

10.2 填充空值

fillna() 方法用于填充 DataFrame 或 Series 中的空值。

10.3 删除空值

dropna() 方法用于删除 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)
print(df)

# 检测空值
is_null = df.isnull()
print(is_null)

# 检测非空值
not_null = df.notnull()
print(not_null)

# 用 0 填充空值
df_filled = df.fillna(0)
print(df_filled)

# 删除包含空值的行
df_dropped = df.dropna()
print(df_dropped)

#删除包含空值的列
df_dropped = df.dropna(axis=1)
print(df_dropped)



"""
     A    B   C
0  1.0  5.0   9
1  2.0  NaN  10
2  NaN  NaN  11
3  4.0  8.0  12
       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
     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
     A    B   C
0  1.0  5.0   9
3  4.0  8.0  12
    C
0   9
1  10
2  11
3  12
"""

三、读取CSV文件

CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）；

CSV 是一种通用的、相对简单的文件格式，被用户、商业和科学广泛应用。

1、to_csv()

to_csv() 方法将 DataFrame 存储为 csv 文件

import pandas as pd

def pd_csv():
    # 创建一个简单的 DataFrame
    data = {
        'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'Los Angeles', 'Chicago']
    }
    df = pd.DataFrame(data)

    # 将 DataFrame 导出为 CSV 文件
    df.to_csv('output.csv', index=False)
pd_csv()

2、read_csv()

read_csv() 表示从 CSV 文件中读取数据，并创建 DataFrame 对象。

import pandas as pd

df = pd.read_csv('output.csv')
print(df)

"""
      Name  Age         City
0    Alice   25     New York
1      Bob   30  Los Angeles
2  Charlie   35      Chicago
"""

四、绘图

Pandas 在数据分析、数据可视化方面有着较为广泛的应用，Pandas 对 Matplotlib 绘图软件包的基础上单独封装了一个plot()接口，通过调用该接口可以实现常用的绘图操作；

Pandas 之所以能够实现了数据可视化，主要利用了 Matplotlib 库的 plot() 方法，它对 plot() 方法做了简单的封装，因此您可以直接调用该接口；

只用 pandas 绘制图片可能可以编译，但是不会显示图片，需要使用 matplotlib 库，调用 show() 方法显示图形。

简单图例：

import pandas as pd
import matplotlib.pyplot as plt

def pd_charts():
    # 创建一个示例 DataFrame
    data = {
        'A': [1, 2, 3, 4, 5],
        'B': [10, 20, 25, 30, 40]
    }
    df = pd.DataFrame(data)

    # 绘制折线图
    df.plot(kind='line')
    # 显示图表
    plt.show()
pd_charts()