Pandas学习

代码死

已于 2025-02-08 20:30:01 修改

阅读量1.7k

点赞数 15

文章标签： pandas 学习人工智能

于 2025-02-07 21:14:51 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_45537879/article/details/145500620

版权

一、Pandas 基础入门

（一）Pandas 概述

Pandas 是基于 Numpy 和 Matplotlib 构建的第三方 Python 库，名字源于 “panel data”（面板数据）与 “Python data analysis”（Python 数据分析）。它能处理各类文件格式数据，广泛应用于多领域，是 Python 数据分析的关键工具。

（二）安装 Pandas

安装 Pandas 很简单，使用 pip 命令并搭配清华镜像源可加快安装：

pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/

（三）内置数据结构

Pandas 在 ndarray 数组的基础上构建出了两种不同的数据结构，分别是 Series（一维数据结构）、DataFrame（二维数据结构）：

Series 是带标签的一维数组，这里的标签可以理解为索引，但这个索引并不局限于整数，它也可以是字符类型，比如 a、b、c 等；

DataFrame 是一种表格型数据结构，它既有行标签，又有列标签，行索引是 index，列索引是 columns。在创建该结构时，可以指定相应的索引值。

1、Series

（1）参数含义

名称	说明
data	一组数据
index	数据索引标签，如果不指定，默认从 0 开始
dtype	数据类型，默认会自己判断
copy	表示对 data 进行拷贝，默认为 False

（2）创建series对象

方法：1、直接赋值创建（用列表创建）

2、用ndarray对象创建

3、用字典创建（key就是series对象的标签，value是对应的值）

4、用标量创建（如果index个数多于标量，则标量按照index的个数进行填充）

import pandas as pd
import numpy as np
 
 
def test01():
    # 创建一个空Series对象
    # s = pd.Series()
    s = pd.Series(dtype=np.int32)
    print(s)
 
    # 通过python列表创建Series，如果不指定index，则默认从0开始
    s = pd.Series([1, 2, 3, 4, 5, 6])
    print(type(s))
 
    # 指定index标签
    index = ['a', 'b', 'c', 'd', 'e']
    s = pd.Series([3, 4, 5, 6, 7], index=index)
    print(s)
 
    # 通过ndarray创建Series对象
    arr = np.array([1, 2, 3, 4, 5])
    s = pd.Series(arr)
    print(s)
 
    # 通过字典创建Series，字典中的key是value的标签
    dic = {'id': 1, 'name': 'zhangsan', 'age': 20}
    s = pd.Series(dic)
    print(s)
 
    # 通过标量创建Series
    s = pd.Series(5)
    print(s)
 
    # 通过标量创建Series，同时指定index，如果index个数多于标量，则标量按照index的个数进行填充
    s = pd.Series(5, index=[1, 2, 3, 4, 5])
    print(s)
 
 
test01()

（3）series常用属性

名称	说明
axes	以列表的形式返回所有行索引标签
dtype	返回对象的数据类型
empty	返回一个布尔值，用于判断数据对象是否为空
ndim	返回输入数据的维数
size	返回输入数据的元素数量
values	以 ndarray 的形式返回 Series 对象
index	返回一个RangeIndex对象，用来描述索引的取值范围

（4）series常用方法

名称	说明
head()	获取前n行数据，默认n=5
tail()	获取后n行数据，默认n=5
isnull()	如果为值不存在或者缺失，则返回 True
notnull()	如果值不存在或者缺失，则返回 False

2、DataFrame

（1）参数含义

名称	说明
data	一组数据
index	数据索引标签，如果不指定，默认从 0 开始
dcoumns	列标签，默认为 RangeIndex
dtype	数据类型
copy	默认为 False ，表示复制数据 data

（2）创建DataFrame对象

import pandas as pd
 
def test():
    # 1.创建DataFrame空对象
    df = pd.DataFrame()
    print(df)
 
    # 2.通过列表创建DataFrame
    df = pd.DataFrame([1, 2, 3])
    print(df)
    # 指定列索引名称
    df = pd.DataFrame([1, 2, 3], columns=['A'])
    print(df)
 
    # 3.通过二维数组创建DataFrame
    data = [['A', 1], ['B', 2], ['C', 3]]
    # 指定列索引和行索引，指定列/行索引时注意索引元素个数要和数据的元素个数一致
    df = pd.DataFrame(data, columns=['name', 'age'], index=['a', 'b', 'c'])
    print(df)
 
    # 4.通过列表嵌套字典创建DataFrame
    # 如果字典中有字段缺失，则默认填充NaN(not a number)
    data = [{'name': 'zhangsan', 'age': 20}, {'name': 'lisi', 'age': 21, 'sex': '男'}]
    df = pd.DataFrame(data)
    print(df)
 
    # 5.通过字典嵌套列表创建DataFrame
    data = {'name': ['zhangsan', 'lisi'], 'age': [20, 30]}
    df = pd.DataFrame(data)
    print(df)
 
    # 6.通过Series对象创建DataFrame
    # DataFrame默认使用Series对象中的索引标签作为DataFrame的行索引
    data = {'name': pd.Series(['zhangsan', 'lisi'], index=['a', 'b']), 'age': pd.Series([10, 20], index=['a', 'b'])}
    df = pd.DataFrame(data)
    print(df)
 
test()

（3）列索引操作

DataFrame 可以使用列索引来完成数据的选取、添加和删除操作。

获取和插入数据

import pandas as pd
 
def test01():

    df = pd.DataFrame({'name': ['zhangsan', 'lisi'], 'age': [20, 30], 'id': [1, 2]})

    # 根据列名获取某一列的数据，结果是列的Series对象
    s = df['name']
    print(s)

    # 将Series转换为python列表
    print(list(s))
 
    # 添加一列空数据，在df中要指定新列名：df['sex']
    df['sex'] = None
    print(df)

    # 添加一列数据，数据的格式可以是python列表、Series对象等
    df['sex'] = ['男', '女']
    print(df)

    # assign(key=values)：添加新列，key作为Dataframe的列名，value作为DataFrame的列值，可以链式调用
    df = df.assign(address=['四川省', '重庆市']).assign(password=['12345', '12345'])
    print(df)
 
    # insert():在指定位置插入一个新列
    # 参数：
    # loc：新列要插入的位置
    # column：要插入的列名
    # value：要插入列值，可以列表、Series等
    df.insert(1, 'tel', ['13812345678', '17712345678'])
    print(df)

修改数据

def test02():
    df = pd.DataFrame({'name': ['zhangsan', 'lisi'], 'age': [20, 30], 'id': [1, 2]})

    # 修改列，通过已存在的列名进行直接赋值即可修改该列的数据
    df['age'] = [40, 50]
    print(df)
 
    # 对某一列进行算术运算，然后再重新赋值给该列
    df['age'] = df['age'] - 10
    print(df)
 
    # 通过直接赋值修改列名
    df.columns = ['A', 'B', 'C']
    print(df)

    # 通过rename方法修改列名
    # 参数：
    # columns：指定新列名，格式：dict，dict中key是旧列名，value是新列名
 
    # columns属性和rename方法区别：columns在原数据上直接修改，rename是先备份一个副本，然后在副本上修改，不影响原数据
    df = df.rename(columns={'A': 'name', 'B': 'age', 'C': 'id'})
    print(df)
    print(df['age'].dtype)
 
    # astype():修改某一列的数据类型
    df['age'] = df['age'].astype('str')
    print(df['age'].dtype)

删除数据

def test03():

    df = pd.DataFrame({'name': ['zhangsan', 'lisi'], 'age': [20, 30], 'id': [1, 2]})

    # drop():删除方法，既可以删除行，也可以删除列
    # 参数：
    # labels：要删除的列/行标签
    # axis：指定按行或按列删除，axis=0表示按行删除，axis=1表示按列删除
    # inplace：是否原地修改，如果为True则在原数据上进行删除，为False则先备份一个副本，然后在副本上进行删除，默认为False
    df1 = df.drop(['id', 'age'], axis=1)
    print(df1)
    print(df)
 
    df.drop(['id'], axis=1, inplace=True)
    print(df)

（4）DataFrame常用属性

名称	说明
T	行和列转置
axes	返回一个仅以行轴标签和列轴标签为成员的列表
dtype	返回每列数据的数据类型
empty	DataFrame 中没有数据或者任意坐标轴的长度为 0 ，则返回 True
ndim	轴的数量，也指数组的维数
size	DataFrame 中的元素数量
values	使用 numpy 数组表示 DataFrame 中的元素值
index	返回一个RangeIndex对象，用来描述索引的取值范围
shape	返回一个元组，表示了 DataFrame 维度

（5）DataFrame常用方法

名称	说明
head()	返回前n行数据
tail()	返回后n行数据

（四）函数

1、常用统计函数

函数名称	说明
count()	统计某个非空值的数量
sum()	求和
mean()	求均值
median()	求中位数
std()	求标准差
min()	求最小值
max()	求最大值
abs()	求绝对值
prod()	求所有数值的乘积

import pandas as pd


def test01():

    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())
    # 输出：
    # A      3.0
    # B     30.0
    # C    300.0
    # dtype: float64

    # 统计指定列的算数平均值
    print(df['A'].mean())
    # 输出：
    # 3.0

    # 指定多列，统计算数平均值
    print(df[['A', 'B']].mean())
    # 输出：
    # A     3.0
    # B    30.0
    # dtype: float64

    # 统计中位数
    print(df.median())
    # 输出：
    # A      3.0
    # B     30.0
    # C    300.0
    # dtype: float64

    # 统计每列的方差，默认是样本方差
    print(df.var())
    # 输出：
    # A        2.5
    # B      250.0
    # C    25000.0
    # dtype: float64

    # 统计每列的标准方差
    print(df.std())
    # 输出：
    # A      1.581139
    # B     15.811388
    # C    158.113883
    # dtype: float64


if __name__ == '__main__':
    test01()

2. 重置索引

重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。

（1） `reindex()`

reindex() 方法用于重新索引 DataFrame 或 Series 对象。重新索引意味着根据新的索引标签重新排列数据，并填充缺失值。

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)

（2） `reindex_like()`

reindex_like() 方法用于将一个 DataFrame 或 Series 的索引重新排列，使其与另一个 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'])

# 使用 reindex_like 对齐 df1 的行索引到 df2
df1_reindexed = df1.reindex_like(df2)
print(df1_reindexed)

3. 遍历

Pandas 提供了多种遍历 DataFrame 和 Series 的方法。

（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]}")

（2） DataFrame 遍历

使用 iterrows() 方法：

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

# 使用 iterrows() 遍历行
for index, row in df.iterrows():
    print(f"Index: {index}, Row: {row}")

使用 itertuples() 方法：

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

# 使用 itertuples() 遍历行
for row in df.itertuples():
    print(row)

4. 排序

（1） `sort_index()`

sort_index() 方法用于对 DataFrame 或 Series 的索引进行排序。

import pandas as pd

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

# 按行索引排序
df_sorted = df.sort_index()
print(df_sorted)

（2） `sort_values()`

sort_values() 方法用于根据一个或多个列的值对 DataFrame 进行排序。

import pandas as pd

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

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)

6. 分组

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

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' 分组
grouped = df.groupby('A')

# 查看分组结果
for name, group in grouped:
    print(f"Group: {name}")
    print(group)
    print()

7. 合并

merge() 函数用于将两个 DataFrame 对象根据一个或多个键进行合并，类似于 SQL 中的 JOIN 操作。

import pandas as pd

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