数据分析 — Pandas 数据加载、存储和清洗

一、文件读取
- 1、常见文件读取函数
- 2、read_csv()
- 3、read_table()
- 4、read_excel()
- 5、read_json()
- 6、read_html()
- 7、大文件读取
二、数据保存
- 1、csv
- 2、excel
- 3、json
- 4、html
- 5、MySQL
- - 1、连接数据库
  - 2、MySQL 存储到本地
  - 3、本地存储到 MySQL
三、数据清洗
- 1、处理缺失值
- - 1、判断数据是否为 NAN
  - 2、删除缺失值
  - 3、填充缺失值
- 2、处理异常值
- 3、处理重复值
- - 1、判断是否重复
  - 2、默认保留第一个出现的重复行，后续的重复行将被删除
  - 3、对某列进行去重
- 4、数据转换
- 5、数据离散化
- - 1、按指定边界值切分
  - 2、等距分箱
  - 3、等频分箱
四、应用

一、文件读取

1、常见文件读取函数

函数	说明
read_csv	从文件、URL、文件型对象中加载带分隔符的数据。默认分隔符为逗号。
read_table	从文件、URL、文件型对象中加载带分隔符的数据。默认分隔符为制表符（‘\t’）。
read_excel	从 Excel XLS 或 XLSX file 读取表格数据。
read_json	读取 JSON（JavaScript Object Notation）字符串中的数据。
read_sql	（使用 SQLAlchemy）读取 SQL 查询结果为 pandas 的 DataFrame。
read_html	读取 HTML 文档中的所有表格。
read_hdf	读取 pandas 写的 HDF5 文件。
read_clipboard	读取剪贴板中的数据，可以看做 read_table 的剪贴板版。在将网页转换为表格时很有用。
read_msgpack	二进制格式编码的 pandas 数据。
read_pickle	读取 Python pickle 格式中存储的任意对象。
read_sas	读取存储于 SAS 系统自定义存储格式的 SAS 数据集。
read_fwf	读取定宽列格式数据（也就是说，没有分隔符）。
read_stata	读取 Stata 文件格式的数据集。
read_feather	读取 Feather 二进制文件格式。

2、read_csv()

read_csv() 是 Pandas 库中的函数，用于从 CSV 文件中读取数据并创建一个 DataFrame。

CSV 格式比 Excel 能存储更多数据，CSV 读取性能比 Excel 会高很多。

参数：

filepath_or_buffer：这是必选参数，指定要读取的 CSV 文件的路径或 URL。可以是一个字符串，也可以是类似文件对象的可迭代对象（例如文件句柄）。
sep：指定 CSV 文件中的字段分隔符。默认值是逗号（,），但可以根据文件的实际分隔符来设置这个参数，例如制表符（\t）或分号（;）。
delimiter：sep 的别名，用于指定字段分隔符。
header：指定用作列名的行号。通常为整数，如果没有列名行，可以设置为 None。默认值为 0，表示第一行包含列名。
names：如果没有列名行，可以通过此参数提供列名的列表。与 header=None 一起使用。
index_col：用于指定哪一列作为 DataFrame 的索引列。可以是列名、列号或多列的组合。
usecols：指定要读取的列，可以是列名的列表或列号的列表。用于仅读取感兴趣的列，而不是整个文件。
skiprows：指定要跳过的行数，通常用于跳过文件中的标题或注释行。
nrows：指定要读取的行数，可以用于限制读取的数据量。
dtype：用于指定列的数据类型的字典，可以帮助优化内存使用和数据类型转换。
encoding：指定 CSV 文件的字符编码，常见的编码包括 “utf-8”、“ISO8859-1” 等。
parse_dates：指定要解析为日期时间的列，可以是列名或列号的列表。
date_parser：自定义日期时间解析函数，用于将字符串解析为日期时间对象。
na_values：指定要视为缺失值的标记值列表，例如 “NA”、“N/A”、“null” 等。
skipinitialspace：指定是否跳过字段值前的空白字符，默认为 False。
skip_blank_lines：指定是否跳过空白行，默认为 True。
quotechar：指定用于引用字段值的字符，通常为双引号或单引号。
compression：指定文件的压缩格式，例如 “gzip”、“bz2”、“xz” 等。
thousands：用于指定千位分隔符的字符。

常用参数案例：

1、文件路径 path 和编码方式 encoding

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\exa5.csv'
data = pd.read_csv(path,encoding='ANSI')
print(data)

在这里插入图片描述

查看编码方式 encoding
将文件选择记事本方式打开，另存为时有编码方式

2、设置表头 header

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\exa5.csv'
# header=0 表示物理的第一行设置为表头
data = pd.read_csv(path,header=0,encoding='ANSI')
print(data)

在这里插入图片描述

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\exa5.csv'
# header=1 表示物理的第二行设置为表头
data = pd.read_csv(path,header=1,encoding='ANSI')
print(data)

在这里插入图片描述

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\exa5.csv'
# header=None 表示源数据不设置表头
data = pd.read_csv(path,header=None,encoding='ANSI')
print(data)

在这里插入图片描述

3、设置索引列 index_col

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\exa5.csv'
data = pd.read_csv(path,index_col=1,encoding='ANSI')
print(data)

在这里插入图片描述

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\exa5.csv'
data = pd.read_csv(path,index_col='日期',encoding='ANSI')
print(data)

在这里插入图片描述

4、取部分列 usecols

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\exa5.csv'
data = pd.read_csv(path,usecols=[0,2,3],encoding='ANSI')
print(data)

在这里插入图片描述

5、元素的类型 dtype

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\exa5.csv'
data = pd.read_csv(path,encoding='ANSI')
# 查看类型
print(type(data))  # <class 'pandas.core.frame.DataFrame'># 查看元素类型
print(data.dtypes)
# 日期      object
# 股票0    float64
# 股票1    float64
# 股票2    float64
# 股票3    float64
# 股票4    float64
# dtype: object# 查看详细信息摘要
print(data.info())
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 10000 entries, 0 to 9999
# Data columns (total 6 columns):
#  #   Column  Non-Null Count  Dtype
# ---  ------  --------------  -----
#  0   日期      10000 non-null  object
#  1   股票0     10000 non-null  float64
#  2   股票1     10000 non-null  float64
#  3   股票2     10000 non-null  float64
#  4   股票3     10000 non-null  float64
#  5   股票4     10000 non-null  float64
# dtypes: float64(5), object(1)
# memory usage: 468.9+ KB
# None
data2 = pd.read_csv(path,dtype={'股票1':str},encoding='ANSI')
# 查看详细信息摘要
print(data2.info())
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 10000 entries, 0 to 9999
# Data columns (total 6 columns):
#  #   Column  Non-Null Count  Dtype
# ---  ------  --------------  -----
#  0   日期      10000 non-null  object
#  1   股票0     10000 non-null  float64
#  2   股票1     10000 non-null  object
#  3   股票2     10000 non-null  float64
#  4   股票3     10000 non-null  float64
#  5   股票4     10000 non-null  float64
# dtypes: float64(4), object(2)
# memory usage: 468.9+ KB
# None

6、设置某列为日期格式 parse_dates

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\exa5.csv'
data = pd.read_csv(path,parse_dates=['日期'],encoding='ANSI')
print(data.info())
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 10000 entries, 0 to 9999
# Data columns (total 6 columns):
#  #   Column  Non-Null Count  Dtype         
# ---  ------  --------------  -----         
#  0   日期      10000 non-null  datetime64[ns]
#  1   股票0     10000 non-null  float64       
#  2   股票1     10000 non-null  float64       
#  3   股票2     10000 non-null  float64       
#  4   股票3     10000 non-null  float64       
#  5   股票4     10000 non-null  float64       
# dtypes: datetime64[ns](1), float64(5)
# memory usage: 468.9 KB
# None

7、把指定值变成空值 na_values

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\data1.csv'
data = pd.read_csv(path,na_values=[2.52],encoding='ANSI')
print(data)

在这里插入图片描述

3、read_table()

参数同 read_csv()， read_csv() 和 read_table() 之间的区别主要是函数名称，默认分隔符的历史设置。

在当前版本的 Pandas 中，它们几乎可以互相替代，只需根据实际数据文件的分隔符来设置 sep 参数即可。

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\data1.csv'
data = pd.read_table(path,encoding='ANSI')
print(data)

在这里插入图片描述

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\data1.csv'
# 可以读取 csv 文件
data = pd.read_table(path,encoding='ANSI',sep=',')
print(data)

在这里插入图片描述

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\data2.txt'
data = pd.read_table(path)
print(data)

在这里插入图片描述

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\data2.txt'
# 如果分裂空格个数不一致,可使用正则方式进行匹配
data = pd.read_table(path,sep='\s+')
print(data)

在这里插入图片描述

4、read_excel()

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\data3.xlsx'
# 读取表格指定工作表数据
# sheet_name='评论' 或 sheet_name=1
data = pd.read_excel(path,sheet_name='评论')
print(data)

在这里插入图片描述

5、read_json()

// F:\data\data4.json
[{"id": "A001","name": "百度","url": "www.baidu.com"},{"id": "A002","name": "谷歌","url": "www.google.com"},{"id": "A003","name": "淘宝","url": "www.taobao.com"}
]

import pandas as pd  # 导入 Pandas 库并使用别名 pd
path = r'F:\data\data4.json'
data = pd.read_json(path,encoding='utf-8')
print(data)
print(type(data))  # <class 'pandas.core.frame.DataFrame'>
dd = data.to_string()
print(type(dd))  # <class 'str'>

在这里插入图片描述

6、read_html()

import pandas as pd  # 导入 Pandas 库并使用别名 pd
data = pd.read_html('https://www.air-level.com/rank')
print(data)

在这里插入图片描述

import pandas as pd  # 导入 Pandas 库并使用别名 pd
data = pd.read_html('https://www.air-level.com/rank')[0]
print(data)

在这里插入图片描述

7、大文件读取

import pandas as pd  # 导入 Pandas 库并使用别名 pd# 设置文件路径
path = r'F:\data\data1.csv'
# 使用 Pandas 的 read_csv 函数读取 CSV 文件，chunksize=1000 表示每次读取1000行数据，encoding='ANSI' 指定编码方式为ANSI
data = pd.read_csv(path, chunksize=1000, encoding='ANSI')# 创建一个空列表用于存储分块数据
chunks = []
# 遍历每个数据块
for chunk in data:# 将每个数据块转换为 Pandas DataFramechunk = pd.DataFrame(chunk)# 将 DataFrame 添加到 chunks 列表中chunks.append(chunk)
# 使用 concat 函数将所有数据块连接成一个完整的数据集
dataCount = pd.concat(chunks)
# 打印合并后的数据集
print(dataCount)

在这里插入图片描述

二、数据保存

1、csv

data.to_csv('数据.csv',header=True,index=True,mode='w')

2、excel

data.to_excel('./数据.xlsx',sheet_name='详细数据',index=True,header=True)

3、json

data.to_json('数据.json')

4、html

data.to_html('./haha.html',encoding='utf-8')

5、MySQL

1、连接数据库

方式一

import pymysql  # 导入 pymysql 模块，用于连接 MySQL 数据库
import pandas as pd  # 导入 Pandas 库并使用别名 pd# 使用 pymysql.connect() 函数建立 MySQL 数据库连接，提供主机名、用户名、密码、数据库名、端口号和字符集等信息
conn = pymysql.connect(host='localhost',  # 数据库主机名user='root',       # 数据库用户名password='123456',  # 数据库密码db='shop',         # 要连接的数据库名port=3306,          # 数据库端口号，默认为3306charset='utf8'      # 字符集设置为utf8，确保支持中文字符
)# 定义 SQL 查询语句，从名为 "custom" 的表中选取所有数据
sql = """select * from custom"""
# 使用 pandas 的 read_sql() 函数从数据库中读取数据，并存储在 DataFrame 中
data = pd.read_sql(sql, conn)
# 打印 DataFrame 中的数据
print(data)

方式二

import sqlalchemy  # 导入 sqlalchemy 模块，用于数据库连接
import pandas as pd  # 导入 Pandas 库并使用别名 pd# 使用 sqlalchemy.create_engine() 函数创建 MySQL 数据库引擎对象，提供数据库连接信息
engine = sqlalchemy.create_engine('mysql+pymysql://root:123456@localhost:3306/shop?charset=utf8')
# 打印数据库引擎对象，这里主要是为了确认数据库连接信息是否正确
print(engine)# 定义 SQL 查询语句，从名为 "custom" 的表中选取所有数据
sql = """select * from custom"""
# 使用 pandas 的 read_sql() 函数从数据库中读取数据，并存储在 DataFrame 中
data = pd.read_sql(sql, engine)
# 打印 DataFrame 中的数据
print(data)

2、MySQL 存储到本地

data.to_excel('./shop.xlsx')

3、本地存储到 MySQL

data.to_sql(name='custom2',con='mysql+pymysql://root:123456@localhost:3306/shop?charset=utf8',if_exists='replace',index=False)

三、数据清洗

1、处理缺失值

1、判断数据是否为 NAN

import pandas as pd  # 导入 Pandas 库并使用别名 pd
import numpy as np  # 导入 NumPy 库并使用别名 np
data = pd.Series(['one','two',np.nan,'four',np.nan])
print(data)
# 0     one
# 1     two
# 2     NaN
# 3    four
# 4     NaN
# dtype: object# 返回哪些值是缺失值的布尔值
print(pd.isnull(data))
# 0    False
# 1    False
# 2     True
# 3    False
# 4     True
# dtype: bool# 返回值是 isnull 的反集
print(pd.notnull(data))
# 0     True
# 1     True
# 2    False
# 3     True
# 4    False
# dtype: bool

2、删除缺失值

dropna() 是 Pandas 库中的一个函数，用于从数据框（DataFrame）或者 Series 中删除包含缺失值（NaN 或 None）的行或列。
参数：

axis（可选参数）：指定要删除的轴，可以是 0（默认值）表示删除行，或者 1 表示删除列。
- axis=0（默认值）：删除包含缺失值的行。
- axis=1：删除包含缺失值的列。
how（可选参数）：指定删除的方式。
- how=‘any’（默认值）：只要某行或列中存在任何缺失值，就删除该行或列。
- how=‘all’：只有当某行或列中所有元素都是缺失值时，才删除该行或列。
thresh（可选参数）：指定在删除行或列之前必须满足的非缺失值数量的阈值。默认值为 None，表示不考虑阈值。
- 示例：thresh=2：要求至少有 2 个非缺失值才能保留行或列。
subset（可选参数）：指定要考虑的特定行或列的标签（label），默认值为 None。这个参数可以用来针对部分行或列执行 dropna() 操作。
- 示例：subset=[‘column1’, ‘column2’]：只在指定的列中删除包含缺失值的行。
inplace（可选参数）：默认值为 False，表示返回一个新的数据框，不修改原始数据。如果设置为 True，则在原始数据上进行就地修改，并且不返回新的数据框。

1、删除包含缺失值的行

import pandas as pd  # 导入 Pandas 库并使用别名 pd
data = pd.DataFrame({'A': [1, 2, None, 4],'B': [5, None, 7, 8]})
print(data)
#      A    B
# 0  1.0  5.0
# 1  2.0  NaN
# 2  NaN  7.0
# 3  4.0  8.0# 删除包含缺失值的行
result = data.dropna()
print(result)
#      A    B
# 0  1.0  5.0
# 3  4.0  8.0

2、删除包含缺失值的列

import pandas as pd  # 导入 Pandas 库并使用别名 pd
from numpy import nan as NA  # 将NumPy库中的NaN（Not a Number）定义为NA
data = pd.DataFrame([[NA,8,8],[NA,NA,8],[NA,4,5],[NA,7,8]])
print(data)
#     0    1  2
# 0 NaN  8.0  8
# 1 NaN  NaN  8
# 2 NaN  4.0  5
# 3 NaN  7.0  8# 删除包含缺失值的列
result = data.dropna(axis=1)
print(result)
#    2
# 0  8
# 1  8
# 2  5
# 3  8

3、删除所有值为 NaN 的行

import pandas as pd  # 导入 Pandas 库并使用别名 pd
from numpy import nan as NA  # 将NumPy库中的NaN（Not a Number）定义为NA
data = pd.DataFrame([[8,8,8],[NA,NA,NA],[NA,4,5],[NA,7,8]])
print(data)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  NaN  NaN  NaN
# 2  NaN  4.0  5.0
# 3  NaN  7.0  8.0# 删除所有值为 NaN 的行
result = data.dropna(how='all')
print(result)
#      0    1    2
# 0  8.0  8.0  8.0
# 2  NaN  4.0  5.0
# 3  NaN  7.0  8.0

4、至少有 2 个非缺失值才能保留行或列

import pandas as pd  # 导入 Pandas 库并使用别名 pd
from numpy import nan as NA  # 将NumPy库中的NaN（Not a Number）定义为NA
data = pd.DataFrame([[8,8,8],[NA,NA,NA],[NA,NA,5],[NA,7,8]])
print(data)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  NaN  NaN  NaN
# 2  NaN  NaN  5.0
# 3  NaN  7.0  8.0# 至少有 2 个非缺失值才能保留行或列
result = data.dropna(thresh=2)
print(result)
#      0    1    2
# 0  8.0  8.0  8.0
# 3  NaN  7.0  8.0

3、填充缺失值

fillna() 是 Pandas 库中的一个函数，用于在数据框（DataFrame）或者 Series 中填充缺失值（NaN 或 None）。

参数：

value（可选参数）：用于填充缺失值的具体数值或字典，可以是标量（单个数值）、字典（列名与填充值的映射关系）、Series 或者 DataFrame。
method（可选参数）：指定填充缺失值的方法，可以是前向填充（‘ffill’），后向填充（‘bfill’）等。
- method=‘ffill’（默认值）：前向填充。
- method=‘bfill’：后向填充。
axis（可选参数）：指定填充的轴，可以是 0（按列填充）或 1（按行填充）。
- axis=0（默认值）：删除包含缺失值的行。
- axis=1：删除包含缺失值的列。
inplace（可选参数）：是否在原地修改数据框，默认值为 False，表示返回一个新的数据框，不修改原始数据。如果设为 True，将不返回新的数据框，而是直接在原有数据框上进行修改。
limit（可选参数）：用于限制填充的数量，比如设为2，表示每列或每行最多只填充两个缺失值。
downcast（可选参数）：控制数据类型的转换，可以是 ‘integer’、‘signed’、‘unsigned’ 等。

1、填充为0

import pandas as pd  # 导入 Pandas 库并使用别名 pd
from numpy import nan as NA  # 将NumPy库中的NaN（Not a Number）定义为NA
data = pd.DataFrame([[8,8,8],[NA,NA,NA],[NA,NA,5],[NA,7,8]])
print(data)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  NaN  NaN  NaN
# 2  NaN  NaN  5.0
# 3  NaN  7.0  8.0# 填充为0
result = data.fillna(0)
print(result)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  0.0  0.0  0.0
# 2  0.0  0.0  5.0
# 3  0.0  7.0  8.0

2、不同列填充不值

import pandas as pd  # 导入 Pandas 库并使用别名 pd
from numpy import nan as NA  # 将NumPy库中的NaN（Not a Number）定义为NA
data = pd.DataFrame([[8,8,8],[NA,NA,NA],[NA,NA,5],[NA,7,8]])
print(data)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  NaN  NaN  NaN
# 2  NaN  NaN  5.0
# 3  NaN  7.0  8.0# 不同列填充不值
result = data.fillna({0:100,1:200,2:300})
print(result)
#        0      1      2
# 0    8.0    8.0    8.0
# 1  100.0  200.0  300.0
# 2  100.0  200.0    5.0
# 3  100.0    7.0    8.0

3、填充平均值

import pandas as pd  # 导入 Pandas 库并使用别名 pd
from numpy import nan as NA  # 将NumPy库中的NaN（Not a Number）定义为NA
data = pd.DataFrame([[8,8,8],[NA,NA,NA],[NA,NA,5],[NA,7,8]])
print(data)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  NaN  NaN  NaN
# 2  NaN  NaN  5.0
# 3  NaN  7.0  8.0# 填充平均值
result = data.fillna(data.mean())
print(result)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  8.0  7.5  7.0
# 2  8.0  7.5  5.0
# 3  8.0  7.0  8.0

4、向上填充

import pandas as pd  # 导入 Pandas 库并使用别名 pd
from numpy import nan as NA  # 将NumPy库中的NaN（Not a Number）定义为NA
data = pd.DataFrame([[8,8,8],[NA,NA,NA],[NA,NA,5],[NA,7,8]])
print(data)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  NaN  NaN  NaN
# 2  NaN  NaN  5.0
# 3  NaN  7.0  8.0# 向上填充
result = data.fillna(method='ffill')
# 高版本写法
# result = data.ffill()
print(result)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  8.0  8.0  8.0
# 2  8.0  8.0  5.0
# 3  8.0  7.0  8.0

5、向下填充

import pandas as pd  # 导入 Pandas 库并使用别名 pd
from numpy import nan as NA  # 将NumPy库中的NaN（Not a Number）定义为NA
data = pd.DataFrame([[8,8,8],[NA,NA,NA],[NA,NA,5],[NA,7,8]])
print(data)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  NaN  NaN  NaN
# 2  NaN  NaN  5.0
# 3  NaN  7.0  8.0# 向下填充
result = data.fillna(method='bfill')
# 高版本写法
# result = data.bfill()
print(result)
#      0    1    2
# 0  8.0  8.0  8.0
# 1  NaN  7.0  5.0
# 2  NaN  7.0  5.0
# 3  NaN  7.0  8.0

6、把下标为1的列转成字符串

import pandas as pd  # 导入 Pandas 库并使用别名 pd
from numpy import nan as NA  # 将NumPy库中的NaN（Not a Number）定义为NA
data = pd.DataFrame([[8,8,8],[NA,NA,NA],[NA,NA,5],[NA,7,8]])
print(data.info())
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 4 entries, 0 to 3
# Data columns (total 3 columns):
#  #   Column  Non-Null Count  Dtype
# ---  ------  --------------  -----
#  0   0       1 non-null      float64
#  1   1       2 non-null      float64
#  2   2       3 non-null      float64
# dtypes: float64(3)
# memory usage: 224.0 bytes
# None# 把下标为1的列转成字符串
data.iloc[:,1] = data.iloc[:,1].astype(str)
print(data.info())
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 4 entries, 0 to 3
# Data columns (total 3 columns):
#  #   Column  Non-Null Count  Dtype  
# ---  ------  --------------  -----  
#  0   0       1 non-null      float64
#  1   1       4 non-null      object 
#  2   2       3 non-null      float64
# dtypes: float64(2), object(1)
# memory usage: 224.0+ bytes
# None

2、处理异常值

import pandas as pd  # 导入 Pandas 库并使用别名 pd
import numpy as np  # 导入 NumPy 库并使用别名 np
data = pd.DataFrame(np.random.randn(1000,4))
print(data)
#             0         1         2         3
# 0    1.593943 -0.044275  1.657758  0.771481
# 1   -0.747987 -1.225241 -0.306258 -0.457629
# 2    0.902807  0.783800  0.914563 -0.929200
# 3   -1.516675 -0.361840  0.067688 -0.323513
# 4   -0.162813  0.075606  0.828714 -1.907542
# ..        ...       ...       ...       ...
# 995 -0.760415  1.091292  0.453288 -0.072843
# 996 -0.644722 -3.389364  0.462951  1.742291
# 997 -2.130310 -0.406691  0.656790 -1.790120
# 998  0.079858 -1.282808  1.425582  0.118225
# 999 -1.201616 -0.747731 -0.566635  0.396431
#
# [1000 rows x 4 columns]
# 查看大概
# count：非空计数个数，mean：平均值，std：标准差，min：最小值，max：最大值
# 25%：表示25%分位，50%：表示50%分位，75%：表示75%分位
print(data.describe())
#                  0            1            2            3
# count  1000.000000  1000.000000  1000.000000  1000.000000
# mean      0.033990     0.079743    -0.025394    -0.037519
# std       0.987878     0.994122     1.024085     1.017784
# min      -3.422642    -3.389364    -3.218303    -3.292692
# 25%      -0.619548    -0.609269    -0.743909    -0.711874
# 50%       0.048188     0.090974     0.012549    -0.029922
# 75%       0.713032     0.770695     0.682448     0.658831
# max       3.029603     3.100089     3.340088     3.041642
data.iloc[1,1] = 10000
print(data.describe())
#                  0             1            2            3
# count  1000.000000   1000.000000  1000.000000  1000.000000
# mean     -0.014753     10.010379     0.018077    -0.023255
# std       1.021477    316.228973     1.028808     0.994172
# min      -2.811835     -3.671985    -3.021773    -2.878964
# 25%      -0.698100     -0.665801    -0.695405    -0.686040
# 50%      -0.011187     -0.007452    -0.006795     0.008633
# 75%       0.706559      0.708378     0.694225     0.630325
# max       2.966771  10000.000000     3.183331     3.617062

import pandas as pd  # 导入 Pandas 库并使用别名 pd
data = pd.DataFrame({'A': [1, 2, 3, -999, 5],'B': [-1, 7, -999, 9, 10]})
print(data)
#      A    B
# 0    1   -1
# 1    2    7
# 2    3 -999
# 3 -999    9
# 4    5   10# 将异常值-999替换为 NaN
data.replace(-999, float('nan'), inplace=True)
# 输出替换后的数据框
print(data)
#      A     B
# 0  1.0  -1.0
# 1  2.0   7.0
# 2  3.0   NaN
# 3  NaN   9.0
# 4  5.0  10.0# 定义替换规则，将-999替换为 NaN，将-1替换为0
replace_dict = {-999: float('nan'), -1: 0}
# 应用替换规则到数据框
data.replace(replace_dict, inplace=True)
# 输出替换后的数据框
print(data)
#      A     B
# 0  1.0   0.0
# 1  2.0   7.0
# 2  3.0   NaN
# 3  NaN   9.0
# 4  5.0  10.0

Series.replace() 是 Pandas 库中用于替换 Series 中元素值的函数。它允许用户根据指定的规则，将 Series 中的某个值替换为另一个值或一组值。

参数：

to_replace（可选参数）：指定要替换的值。
- 示例：to_replace=5，表示要将 Series 中的所有值为 5 的元素进行替换。
value（可选参数）：用于替换 to_replace 中指定值的具体数值或字典。
- 示例：value=10，表示将 to_replace 中的值为 5 的元素替换为 10。
inplace（可选参数）：是否在原地修改 Series，默认值为 False。如果设为 True，将不返回新的 Series，而是直接在原有 Series 上进行修改。
- 示例：inplace=True，在原始 Series 上就地进行值的替换，不返回新的 Series。
limit（可选参数）：用于限制替换的数量，比如设为2，表示最多只替换两次。默认值为 False。
- 示例：limit=2，最多替换两次。
regex（可选参数）：是否启用正则表达式进行匹配，默认值为 False。如果设为 True，to_replace 可以是正则表达式。
- 示例：regex=True，使用正则表达式进行匹配。
method（可选参数）：指定替换的方法，可选值为 ‘pad’、‘ffill’（前向填充）或 ‘bfill’（后向填充）。
- method=‘pad’：前向填充，也被称为 forward fill，使用该值之前的最近的非缺失值来替换缺失值。
- method=‘ffill’：前向填充，ffill 是 forward fill 的缩写。与 ‘pad’ 相同，使用该值之前的最近的非缺失值来替换缺失值。
- method=‘bfill’：后向填充，也被称为 backward fill。使用该值之后的最近的非缺失值来替换缺失值。

import pandas as pd  # 导入 Pandas 库并使用别名 pd
data = pd.Series([4000,5000,9000,900000,-1000])
data = data.replace(-1000,6000)
print(data)
# 0      4000
# 1      5000
# 2      9000
# 3    900000
# 4      6000
# dtype: int64data = data.replace({900000:9000,-1000:6000})
print(data)
# 0    4000
# 1    5000
# 2    9000
# 3    9000
# 4    6000
# dtype: int64

3、处理重复值

drop_duplicates() 是 Pandas 库中用于删除 DataFrame 或 Series 中重复行的函数。该函数默认根据所有列的数值进行比较，并删除相同的行，保留第一次出现的行。

参数：

subset（可选参数）：指定要考虑的特定列或列的标签，用于确定重复性。只考虑这些列的数值，而不是整行。默认值为 False。
- 示例：subset=[‘column1’, ‘column2’]，只在指定的列中判断重复性。
keep（可选参数）：确定保留哪个重复的实例。
- keep= ‘first’（默认值）：保留第一次出现的实例。
- keep=‘last’：保留最后一次出现的实例。
- keep=False：删除所有重复的实例。
inplace（可选参数）：是否在原地修改 DataFrame 或 Series，如果设为 True，将不返回新的对象，而是直接在原有对象上进行修改。默认值为 False。
- 示例：inplace=True，在原始 DataFrame 或 Series 上就地删除重复行，不返回新的对象。

1、判断是否重复

import pandas as pd  # 导入 Pandas 库并使用别名 pd
data = pd.DataFrame({'k1':list('abababaa'),'k2':[1,1,2,2,3,3,4,4]})
print(data)
#   k1  k2
# 0  a   1
# 1  b   1
# 2  a   2
# 3  b   2
# 4  a   3
# 5  b   3
# 6  a   4
# 7  a   4# 判断是否重复
print(data.duplicated().sum())  # 1

2、默认保留第一个出现的重复行，后续的重复行将被删除

import pandas as pd  # 导入 Pandas 库并使用别名 pd
data = pd.DataFrame({'k1':list('abababaa'),'k2':[1,1,2,2,3,3,4,4]})
print(data)
#   k1  k2
# 0  a   1
# 1  b   1
# 2  a   2
# 3  b   2
# 4  a   3
# 5  b   3
# 6  a   4
# 7  a   4# 默认保留第一个出现的重复行，后续的重复行将被删除
print(data.drop_duplicates())
#   k1  k2
# 0  a   1
# 1  b   1
# 2  a   2
# 3  b   2
# 4  a   3
# 5  b   3
# 6  a   4

3、对某列进行去重

import pandas as pd  # 导入 Pandas 库并使用别名 pd
data = pd.DataFrame({'k1':list('abababaa'),'k2':[1,1,2,2,3,3,4,4]})
print(data)
#   k1  k2
# 0  a   1
# 1  b   1
# 2  a   2
# 3  b   2
# 4  a   3
# 5  b   3
# 6  a   4
# 7  a   4# 对某列进行去重
print(data.drop_duplicates(['k1']))
#   k1  k2
# 0  a   1
# 1  b   1

4、数据转换

需求：data 加一列 “animal”

1、对 food 处理，把它全部变成小写

2、使用 map 对字典映射

3、加入到原数据里

import pandas as pd  # 导入 Pandas 库并使用别名 pd
data = pd.DataFrame({'food':['Banana','bone','Grass','fish','worm'],'calorie':[10,20,30,40,50]})
print(data)
#      food  calorie
# 0  Banana       10
# 1    bone       20
# 2   Grass       30
# 3    fish       40
# 4    worm       50eat_animal = {'grass':'cattle','banana':'monkey','fish':'cat','worm':'frog' ,'bone':'dog'
}
data["animal"] = data['food'].str.lower().map(eat_animal)
print(data)
#      food  calorie  animal
# 0  Banana       10  monkey
# 1    bone       20     dog
# 2   Grass       30  cattle
# 3    fish       40     cat
# 4    worm       50    frog

5、数据离散化

pd.cut() 是 Pandas 中用于将连续数据分割成离散区间的函数，通常用于数据的离散化或分箱处理。

参数：

x（必需参数）：要分割的数据，可以是 Series 或数组。
bins（必需参数）：用于指定分割区间的边界值，可以是一个整数、序列（例如列表或数组），或者一个区间数。如果是整数，表示分成的等宽区间数；如果是序列，表示自定义的分割点；如果是区间数，表示区间范围。
labels（可选参数）：用于指定每个区间的标签，通常是字符串或者其他可哈希的对象。如果未指定，结果将包含区间的标签。
right（可选参数，默认为 True）：指定区间的开闭，如果为 True，区间右侧是闭区间，如果为 False，区间右侧是开区间。
include_lowest（可选参数，默认为 False）：指定最左侧的区间是否包含在分箱中。
retbins（可选参数，默认为 False）：如果为 True，则返回划分的区间。
precision（可选参数）：区间精度，用于四舍五入区间边界值。

import pandas as pd  # 导入 Pandas 库并使用别名 pd
import numpy as np  # 导入 NumPy 库并使用别名 np
# 创建一个示例的一维数组
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
# 定义区间的方式
bins = [0, 3, 6, 9, 12]
# 使用 pd.cut() 进行离散化
data = pd.cut(data, bins, right=True, labels=['Category 1', 'Category 2', 'Category 3', 'Category 4'])
# 输出离散化后的数据
print(data)
# ['Category 1', 'Category 1', 'Category 1', 'Category 2', 'Category 2', 'Category 2', 'Category 3', 'Category 3', 'Category 3', 'Category 4']
# Categories (4, object): ['Category 1' < 'Category 2' < 'Category 3' < 'Category 4']

1、按指定边界值切分

import pandas as pd  # 导入 Pandas 库并使用别名 pd
data = pd.DataFrame({'Scores': [85, 92, 78, 60, 72, 88, 92, 98, 55, 75]})
print(data)
#    Scores
# 0      85
# 1      92
# 2      78
# 3      60
# 4      72
# 5      88
# 6      92
# 7      98
# 8      55
# 9      75# 按指定边界值切分
bins = [0,60,70,80,90,100]
# 使用 right=False 表示右边不包含 [0,60) [60,70) [70,80)... labels 给分段打标签
data['Level']=pd.cut(data['Scores'],bins,labels=['E','D','C','B','A'],right=False)
print(data)
#    Scores Level
# 0      85     B
# 1      92     A
# 2      78     C
# 3      60     D
# 4      72     C
# 5      88     B
# 6      92     A
# 7      98     A
# 8      55     E
# 9      75     C

2、等距分箱

import pandas as pd  # 导入 Pandas 库并使用别名 pd
import numpy as np  # 导入 NumPy 库并使用别名 np
# 等距分箱 --- 区间相等或近似相等
data = np.random.randint(1,30,30)
print(data)
# [10 17  6 17 13 29 14 21 27  2  1  5 20 13 18  3 28  1 20  5  4 23 17 22 16 26  8 18 18 23]dd = pd.cut(data,5)
# 统计值的个数
print(dd.value_counts())
# (0.972, 6.6]    9
# (6.6, 12.2]     9
# (12.2, 17.8]    2
# (17.8, 23.4]    5
# (23.4, 29.0]    5
# Name: count, dtype: int64

3、等频分箱

import pandas as pd  # 导入 Pandas 库并使用别名 pd
import numpy as np  # 导入 NumPy 库并使用别名 np
# 等频分箱---落在每个区间的数据点的个数相等或近似相等
data = np.random.randint(1,100,50)  # 取1-100之间的随机整数，取50个
print(data)
# [55  2  7 57 82 62 78 13  5 31 82 98 26 50 72 92 34 49 72 26 16 21  9 21 6 47 57 12 53 48 99 95 11 43 91 19 39 50 54 82 51 45 59 90 54 25 18 67 53 62]# 分为4个区间
dd = pd.qcut(data,4)
print(dd.value_counts())
# (1.999, 22.0]    13
# (22.0, 50.0]     13
# (50.0, 65.75]    11
# (65.75, 99.0]    13
# Name: count, dtype: int64

四、应用

按需求清洗数据

import pandas as pd  # 导入 Pandas 库并使用别名 pd
import numpy as np  # 导入 NumPy 库并使用别名 np
# 读取 CSV 文件到 DataFrame，设置第一列为索引
data = pd.read_csv(r'F:\data\电子产品销售分析.csv', index_col=0)
# 显示数据集的前几行
data.head()

在这里插入图片描述

# 查看数据集的概览信息
data.info()

在这里插入图片描述

# 处理 'event_time' 列，提取日期和时间
f = lambda x: x.split(' ')[0]  # 定义匿名函数提取日期
data['date'] = data['event_time'].map(f)  # 创建新的 'date' 列存储日期
# 显示数据集的前几行
data.head()

在这里插入图片描述

f = lambda x: x.split(' ')[1]  # 定义匿名函数提取时间
data['time'] = data['event_time'].map(f)  # 创建新的 'time' 列存储时间
# 显示数据集的前几行
data.head()

在这里插入图片描述

# 查看数据集的概览信息
data.info()

在这里插入图片描述

# 将 'date' 列转换为日期格式
data['date'] = pd.to_datetime(data['date'])
# 查看数据集的概览信息
data.info()

在这里插入图片描述

# 提取日期中的月份，年份和季度
data['month'] = data['date'].dt.month
data['year'] = data['date'].dt.year
data['quarter'] = data['date'].dt.quarter
# 显示数据集的前几行
data.head()

在这里插入图片描述

# 查看数据集的概览信息
data.info()

在这里插入图片描述

# 将 'user_id' 和 'category_id' 列转换为整数类型
data['user_id'] = data['user_id'].astype('int')
data['category_id'] = data['category_id'].astype('int')
# 查看数据集的概览信息
data.info()

在这里插入图片描述

# 检查数据集中的缺失值
data.isnull().sum()
# 将 'category_code' 列的空值填充为 'N'
data['category_code'].fillna('N', inplace=True)
# 查看数据集的概览信息
data.info()

在这里插入图片描述

# 删除数据集中的重复值
data.drop_duplicates(inplace=True)
# 检查数据集中的异常值，使用 describe() 默认只统计数值数据
data.describe(include='all')
# 按条件筛选数据集，保留 'date' 大于等于 '2020-01-01' 的行
data2 = data[data['date'] >= '2020-01-01']
# 显示数据集的前几行
data2.head()

在这里插入图片描述

# 打印筛选后的数据集的形状
data2.shape  # (562188, 16)

记录学习过程，欢迎讨论交流，尊重原创，转载请注明出处~