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、内置数据结构

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

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

• DataFrame 是一种表格型数据结构，它既有行标签，又有列标签

数据结构	维度	说明
Series	1	该结构能够存储各种数据类型，比如字符数、整数、浮点数、Python 对象等，Series 用 name 和 index 属性来描述数据值。Series 是一维数据结构，因此其维数不可以改变
DataFrame	2	DataFrame 是一种二维表格型数据的结构，既有行索引，也有列索引。行索引是 index，列索引是 columns。 在创建该结构时，可以指定相应的索引值

3、Series

Pandas Series 类似表格中等一个列（column），类似于一维数组，可以保存任何数据类型 Series 由索引（index）和列组成，函数：

函数名	参数
pandas.Series(data,index,dtype)	data：一组数据（ndarray 类型） index：数据索引标签，如果不指定，默认从 0 开始 dtype：数据类型，默认会自己判断 copy：表示对 data 进行拷贝，默认为 False

结构图：

 

3.1 创建 Series 对象的方式

3.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)

3.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

3.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

3.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

3.2 访问 Series 数据

import pandas as pd

def five():
    data = {"name": "陈蕾", "gender": "男"}
    result = pd.Series(data=data)
    print(result["name"])
    print(result[1])

3.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)

3.4 Series 常用方法

3.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())

3.4.2 isnull() 和 notnull()

isnull() 和 notnull() 用于检测 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

4、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：索引值，或者可以称为行标签 columns：列标签，默认为 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

4.1 创建 DataFrame 对象

创建 DataFrame 对象的方式：

• 列表

• 字典

• Series

• Numpy ndarrays

• 另一个 DataFrame

4.1.1 创建 DataFrame 空对象

import pandas as pd

# 创建 DataFrame 空对象
def one():
    result = pd.DataFrame()
    print(result)

4.1.2 列表创建 DataFrame 对象

案例：

import pandas as pd

# 列表创建 DataFrame 对象
def three():
    data = ['小明','小红','小紫']
    column = ['name']
    result = pd.DataFrame(data=data,columns=column)
    print(result)

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

案例：

import pandas as pd

# 列表创建 DataFrame 对象
def three():
    data = [['小米', 18], ['小红', 19], ['小紫', 20]]
    result = pd.DataFrame(data=data,columns=['name','age'])
    print(result)

4.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   小红      男

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

案例：

import pandas as pd

# 典创建 DataFrame 对象
def five():
    data = {"name":['小米','小红','小紫'],"age":[18,19,20]}
    result = pd.DataFrame(data=data)
    print(result)

4.1.5 Series 创建 DataFrame 对象

默认使用series的索引作为行标签

案例：对于 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)

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

4.2 列索引操作

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

也可以通过布尔索引获取数据

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

4.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)

 案例2：添加新列，直接赋值添加

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)

案例3：通过assign方法添加新列

assign 方法可以用于添加新列，并且可以链式调用(函数返回类本身)。

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)

 案例4：通过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)

案例5：在指定的位置插入新列

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

• loc: 插入位置的列索引。

• column: 新列的名称。

• value: 要插入的 Series。

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

4.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)

 案例2：基于现有列的值修改列

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)

 案例3：修改列名，columns属性原地修改

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)

 案例4：使用 rename 方法修改列名

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)

4.2.4 删除数据

. 通过drop方法删除 DataFrame 中的数据，默认情况下，drop() 不会修改原 DataFrame，而是返回一个新的 DataFrame。

语法：

DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')

参数：

1. labels：

   • 类型：单个标签或列表。

   • 描述：要删除的行或列的标签。如果 axis=0，则 labels 表示行标签；如果 axis=1，则 labels 表示列标签。

2. axis：

   • 类型：整数或字符串，默认为 0。

   • 描述：指定删除的方向。axis=0 或 axis='index' 表示删除行，axis=1 或 axis='columns' 表示删除列。

3. index：

   • 类型：单个标签或列表，默认为 None。

   • 描述：要删除的行的标签。如果指定，则忽略 labels 参数。

4. columns：

   • 类型：单个标签或列表，默认为 None。

   • 描述：要删除的列的标签。如果指定，则忽略 labels 参数。

5. level：

   • 类型：整数或级别名称，默认为 None。

   • 描述：用于多级索引（MultiIndex），指定要删除的级别。

6. inplace：

   • 类型：布尔值，默认为 False。

   • 描述：如果为 True，则直接修改原 DataFrame，而不是返回一个新的 DataFrame。

7. errors：

   • 类型：字符串，默认为 'raise'。

   • 描述：指定如何处理不存在的标签。'raise' 表示抛出错误，'ignore' 表示忽略错误。

案例1：删除列

import pandas as pd

result = pd.DataFrame()
result['one'] = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
result['two'] = pd.Series([5, 6, 7, 8], index=['a', 'b', 'c', 'd'])
print(result)

result1 = result.drop(['one'],axis=1)
print(result1)

 案例2：删除行

result = pd.DataFrame()
result['one'] = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
result['two'] = pd.Series([5, 6, 7, 8], index=['a', 'b', 'c', 'd'])
print(result)

result1 = result.drop(['a'],axis=0)
print(result1)

案例3：直接删除原DataFrame和行或列

result = pd.DataFrame()
result['one'] = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
result['two'] = pd.Series([5, 6, 7, 8], index=['a', 'b', 'c', 'd'])
print(result)

result.drop(['a'], axis=0, inplace=True)
print(result)

4.3 行索引操作

4.3.1 loc 选取数据

df.loc[] 只能使用标签索引，不能使用整数索引。当通过标签索引的切片方式来筛选数据时，它的取值前闭后闭，也就是只包括边界值标签（开始和结束）

loc方法返回的数据类型：

1.如果选择单行或单列，返回的数据类型为Series

2.选择多行或多列，返回的数据类型为DataFrame

3.选择单个元素(某行某列对应的值)，返回的数据类型为该元素的原始数据类型（如整数、浮点数等）。、

语法：

DataFrame.loc[row_indexer, column_indexer]

**参数**：

- row_indexer：**行标签或布尔数组**。
- column_indexer：**列标签或布尔数组**。

**案例：*df.loc['a':'c']    # 选择行标签从 'a' 到 'c' 的行，包括'c'行**

4.3.2 iloc 选取数据

iloc 方法用于基于位置（integer-location based）的索引，即通过行和列的整数位置来选择数据。

语法：

DataFrame.iloc[row_indexer, column_indexer]

参数：

• row_indexer：行位置或布尔数组。

• column_indexer：列位置或布尔数组。

可能返回视图的情况：

当使用 iloc 进行连续切片选取数据时，Pandas 有可能返回视图。视图是指返回的对象和原 DataFrame 或 Series 共享底层数据，对视图进行修改会影响原数据。

可能返回副本的情况：

当使用 iloc 进行非连续索引或者布尔索引选取数据时，通常会返回副本。副本是一个独立的对象，和原数据不共享底层数据，对副本进行修改不会影响原数据。

案例：df.iloc[0:2] # 选择第 0 到 1 行的数据，不包括第二行

4.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)

# 错误操作
print(result['a'])
print(result['a':'c','B'])

 切片获取行和通过iloc方法获取行从结果上没有区别，切片是基于位置的切片操作，iloc是基于位置的索引操作。

4.3.4 添加数据行

案例1：添加新行

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

print("添加新行后的 DataFrame:")
print(df)

concat

concat 函数返回的是一个副本

语法：

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，则复制数据。

案例1：按行连接（垂直堆叠），与列索引有关

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

df2 = pd.DataFrame({
    'A': [7, 8, 9],
    'B': [10, 11, 12],
    'C': [13, 14, 15]
})

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

print(result)

案例2：使用 ignore_index  

# 创建两个示例 DataFrame
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, ignore_index=True)

print(result)

 

案例3：使用 join='inner'，按行合并

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

4.3.5 删除数据行

您可以使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。使用的是 drop 函数，上文中已有，这里就不再赘述！

4.4 常用属性和方法

DataFrame 的属性和方法，与 Series 基本相同

名称	属性和方法描述
T	行和列转置。
axes	返回一个仅以行轴标签和列轴标签为成员的列表。
dtypes	返回每列数据的数据类型。
empty	DataFrame中没有数据或者任意坐标轴的长度为0，则返回True。
ndim	轴的数量，也指数组的维数。
shape	返回一个元组，表示了 DataFrame 维度。
size	DataFrame中的元素数量。
values	使用 numpy 数组表示 DataFrame 中的元素值。
head()	返回前 n 行数据。
tail()	返回后 n 行数据。

 

二、读取CSV文件

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

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

1、to_csv()

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

2、read_csv()

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

案例：

import pandas as pd

def test01():
    data = {
        'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'Los Angeles', 'Chicago']
    }
    df = pd.DataFrame(data)
    df.to_csv('pandas_test.csv', index=False)
    df1 = pd.read_csv('pandas_test.csv')
    print(df1)

 

三、绘图

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

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

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

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)

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

# 绘制柱状图
df.plot(kind='bar')
# 显示图表
plt.show()

# 绘制直方图
df['A'].plot(kind='hist')
# 显示图表
plt.show()

# 绘制散点图
df.plot(kind='scatter', x='A', y='B')
# 显示图表
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()