07 章: 数据清洗与准备

import numpy as np  # 导入 NumPy 库，用于数值计算
import pandas as pd  # 导入 Pandas 库，用于数据分析

float_data = pd.Series([1.2, -3.5, np.nan, 0])  # 创建一个包含浮点数和 NaN 的 Series
float_data  # 显示 Series

float_data.isna()  # 使用 .isna() 方法检查 Series 中的缺失值

string_data = pd.Series(["aardvark", np.nan, None, "avocado"])  # 创建一个包含字符串、NaN 和 None 的 Series
string_data  # 显示 Series

string_data.isna()  # 使用 .isna() 方法检查缺失值，None 也会被识别为缺失值

float_data = pd.Series([1, 2, None], dtype='float64') #即便序列中给定的是None，在指定类型为float64后，会被转换为NaN
float_data

float_data.isna()

data = pd.Series([1, np.nan, 3.5, np.nan, 7])  # 创建一个包含数值和 NaN 的 Series
data.dropna()  # 使用 .dropna() 方法删除包含 NaN 的元素

data = pd.DataFrame([[1., 6.5, 3.], [1., np.nan, np.nan],
                     [np.nan, np.nan, np.nan], [np.nan, 6.5, 3.]])  # 创建一个包含数值和 NaN 的 DataFrame
data  # 显示 DataFrame

data.dropna()  # 默认情况下，.dropna() 会删除包含任何 NaN 值的行

data.dropna(how="all")  # 使用 how="all" 参数，只删除所有值都为 NaN 的行

data[4] = np.nan  # 添加一个新列，所有值都为 NaN
data  # 显示 DataFrame

data.dropna(axis="columns", how="all")  # 使用 axis="columns" 和 how="all" 删除所有值都为 NaN 的列

df = pd.DataFrame(np.random.standard_normal((7, 3)))  # 创建一个包含随机数的 DataFrame
df.iloc[:4, 1] = np.nan  # 将第 1 列的前 4 个值设置为 NaN
df.iloc[:2, 2] = np.nan  # 将第 2 列的前 2 个值设置为 NaN
df  # 显示 DataFrame

df.dropna()  # 默认情况下，删除包含任何 NaN 值的行

df.dropna(thresh=2)  # 使用 thresh=2 参数，保留至少有 2 个非 NaN 值的行

df.fillna(0)  # 使用 .fillna(0) 将所有 NaN 值替换为 0

df.fillna({1: 0.5, 2: 0})  # 使用字典为不同的列指定不同的填充值，这里将第1列的NaN值填充为0.5，第2列的NaN值填充为0

df = pd.DataFrame(np.random.standard_normal((6, 3)))  # 创建一个包含随机数的 DataFrame
df.iloc[2:, 1] = np.nan  # 将第 1 列的第 2 行之后的值设置为 NaN
df.iloc[4:, 2] = np.nan  # 将第 2 列的第 4 行之后的值设置为 NaN
df  # 显示 DataFrame

df.fillna(method="ffill")  # 使用 method="ffill" 进行前向填充，将上一个有效值传播到后续的 NaN 值

df.fillna(method="ffill", limit=2)  # 使用 limit=2 参数限制前向填充连续 NaN 值的数量

data = pd.Series([1., np.nan, 3.5, np.nan, 7])  # 创建一个包含数值和 NaN 的 Series
data.fillna(data.mean())  # 使用 .fillna(data.mean()) 将 NaN 值替换为 Series 的平均值

data = pd.DataFrame({"k1": ["one", "two"] * 3 + ["two"],
                     "k2": [1, 1, 2, 3, 3, 4, 4]})  # 创建一个包含重复行的 DataFrame
data  # 显示 DataFrame

data.duplicated()  # 使用 .duplicated() 方法检查 DataFrame 中的重复行

data.drop_duplicates()  # 使用 .drop_duplicates() 方法删除重复行，默认保留第一个出现的行

data["v1"] = range(7)  # 添加一个新列
data  # 显示 DataFrame

data.drop_duplicates(subset=["k1"])  # 使用 subset 参数指定要检查重复项的列的子集，这里只考虑 "k1" 列

data.drop_duplicates(["k1", "k2"], keep="last")  # 使用 keep="last" 参数保留每个唯一行 (或列组合) 的最后一个出现

data = pd.DataFrame({"food": ["bacon", "pulled pork", "bacon",
                              "pastrami", "corned beef", "bacon",
                              "pastrami", "honey ham", "nova lox"],
                     "ounces": [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})  # 创建一个包含食品和重量信息的 DataFrame
data  # 显示 DataFrame

meat_to_animal = {
  "bacon": "pig",
  "pulled pork": "pig",
  "pastrami": "cow",
  "corned beef": "cow",
  "honey ham": "pig",
  "nova lox": "salmon"
}  # 创建一个字典，将每种食物映射到对应的动物

data["animal"] = data["food"].map(meat_to_animal)  # 使用 .map() 方法和映射字典将 "food" 列映射到 "animal" 列
data  # 显示 DataFrame

def get_animal(x):  # 定义一个函数，根据食物名称返回对应的动物
    return meat_to_animal[x]

data["food"].map(get_animal)  # 使用 .map() 方法和自定义函数将 "food" 列映射到动物类型

data = pd.Series([1., -999., 2., -999., -1000., 3.])  # 创建一个包含数值和一些表示缺失值的特殊值的 Series
data  # 显示 Series

data.replace(-999, np.nan)  # 使用 .replace() 方法将 -999 替换为 NaN

data.replace([-999, -1000], np.nan)  # 使用 .replace() 方法一次性替换多个值，将 -999 和 -1000 都替换为 NaN

data.replace([-999, -1000], [np.nan, 0])  # 使用 .replace() 方法为不同的旧值指定不同的替换值，将 -999 替换为 NaN，将 -1000 替换为 0

data.replace({-999: np.nan, -1000: 0})  # 使用字典进行替换，将 -999 替换为 NaN，将 -1000 替换为 0

data = pd.DataFrame(np.arange(12).reshape((3, 4)),
                    index=["Ohio", "Colorado", "New York"],
                    columns=["one", "two", "three", "four"])  # 创建一个 DataFrame，并指定行索引和列索引
data  # 显示 DataFrame

def transform(x):  # 定义一个函数，将字符串的前四个字符转换为大写
    return x[:4].upper()

data.index.map(transform)  # 使用 .map() 方法和自定义函数转换行索引

data.index = data.index.map(transform)  # 将转换后的索引赋值给 data.index，以修改 DataFrame 的行索引
data

data.rename(index=str.title, columns=str.upper)  # 使用 .rename() 方法创建转换后的副本，而不修改原始 DataFrame，将行索引首字母大写，列索引全部大写

data.rename(index={"OHIO": "INDIANA"},
            columns={"three": "peekaboo"})  # 使用字典对部分轴标签进行重命名，将行索引 "OHIO" 重命名为 "INDIANA"，将列索引 "three" 重命名为 "peekaboo"

ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]  # 创建一个年龄列表
bins = [18, 25, 35, 60, 100]  # 定义分箱边界
age_categories = pd.cut(ages, bins)  # 使用 pd.cut() 函数将年龄数据分箱
age_categories  # 显示分箱结果

age_categories.codes  # 查看每个年龄对应的箱的编码

age_categories.categories  # 查看箱的类别 (区间)

age_categories.categories[0]  # 查看第一个箱的区间

pd.value_counts(age_categories)  # 使用 pd.value_counts() 统计每个箱中的元素数量

pd.cut(ages, bins, right=False)  # 使用 right=False 参数更改区间的闭合侧，变为左闭右开

group_names = ["Youth", "YoungAdult", "MiddleAged", "Senior"]  # 定义箱的标签
pd.cut(ages, bins, labels=group_names)  # 使用 labels 参数为箱指定自定义名称

data = np.random.uniform(size=20)  # 生成 20 个均匀分布的随机数
pd.cut(data, 4, precision=2)  # 将数据分成 4 个等长的箱，并设置精度为 2

data = np.random.standard_normal(1000)  # 生成 1000 个标准正态分布的随机数
quartiles = pd.qcut(data, 4, precision=2)  # 将数据分成四分位数，并设置精度为 2
quartiles  # 显示分箱结果

pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.]).value_counts()  # 使用自定义分位数进行分箱，并统计每个箱中的元素数量

data = pd.DataFrame(np.random.standard_normal((1000, 4)))  # 创建一个包含 1000 行 4 列标准正态分布随机数的 DataFrame
data.describe()  # 查看 DataFrame 的描述性统计信息

col = data[2]  # 选择第 2 列
col[col.abs() > 3]  # 找出第 2 列中绝对值大于 3 的值

data[(data.abs() > 3).any(axis="columns")]  # 选择包含至少一个绝对值大于 3 的值的行

data[data.abs() > 3] = np.sign(data) * 3  # 将绝对值大于 3 的值限制为 -3 或 3
data.describe()  # 查看 DataFrame 的描述性统计信息

df = pd.DataFrame(np.arange(5 * 7).reshape((5, 7)))  # 创建一个示例 DataFrame
df  # 显示 DataFrame

sampler = np.random.permutation(5)  # 生成一个包含 0-4 的随机排列的数组
sampler  # 显示排列

df.take(sampler)  # 使用 .take() 方法和排列对 DataFrame 的行进行重新排序，也可以使用 df.iloc[sampler]

column_sampler = np.random.permutation(7)  # 生成一个包含 0-6 的随机排列的数组
column_sampler  # 显示排列

df.take(column_sampler, axis="columns")  # 使用 .take() 方法、排列和 axis="columns" 对 DataFrame 的列进行重新排序

df.sample(n=3)  # 使用 .sample(n=3) 随机选择 3 行 (不放回)

choices = pd.Series([5, 7, -1, 6, 4])  # 创建一个 Series
choices.sample(n=10, replace=True)  # 使用 .sample(n=10, replace=True) 随机选择 10 个元素 (有放回)

df = pd.DataFrame({"key": ["b", "b", "a", "c", "a", "b"],
                   "data1": range(6)})  # 创建一个包含分类变量 "key" 的 DataFrame
df  # 显示 DataFrame

pd.get_dummies(df["key"])  # 使用 pd.get_dummies() 函数将分类变量转换为虚拟变量

dummies = pd.get_dummies(df["key"], prefix="key")  # 使用 prefix 参数为虚拟变量的列名添加前缀
df_with_dummy = df[["data1"]].join(dummies)  # 将虚拟变量与原始 DataFrame 连接
df_with_dummy  # 显示结果 DataFrame

mnames = ["movie_id", "title", "genres"]  # 定义列名
movies = pd.read_table("datasets/movielens/movies.dat", sep="::",
                       header=None, names=mnames, engine="python")  # 读取 MovieLens 数据集，分隔符为 "::"
movies[:10]  # 显示前 10 行数据

dummies = movies["genres"].str.get_dummies("|")  # 使用 str.get_dummies("|") 处理多个类别，分隔符为 "|"
dummies.iloc[:10, :6]  # 显示前 10 行和前 6 列

movies_windic = movies.join(dummies.add_prefix("Genre_"))  # 将虚拟变量与原始 DataFrame 连接，并为虚拟变量列名添加前缀


movies_windic.iloc[0] # 显示结果 DataFrame 的第一行

np.random.seed(12345) # 设置随机数种子以确保结果可重复
values = np.random.uniform(size=10) # 生成 10 个均匀分布的随机数
values # 显示随机数

bins = [0, 0.2, 0.4, 0.6, 0.8, 1] # 定义分箱边界
pd.get_dummies(pd.cut(values, bins)) # 将数据分箱，然后转换为虚拟变量

s = pd.Series([1, 2, 3, None]) # 创建一个包含整数和 None 的 Series
s # 显示 Series

s.dtype # 查看 Series 的数据类型

s = pd.Series([1, 2, 3, None], dtype=pd.Int64Dtype()) # 使用 pd.Int64Dtype() 创建一个可空整数 Series
s # 显示 Series

s.isna() # 检查缺失值，None 会被正确识别为缺失值

s.dtype # 查看 Series 的数据类型

s = pd.Series(['one', 'two', None, 'three'], dtype=pd.StringDtype()) # 使用 pd.StringDtype() 创建一个专门的字符串 Series
s # 显示 Series

s.dtype #查看 Series 的数据类型

df = pd.DataFrame({"A": [1, 2, None, 4],
                    "B": ["one", "two", "three", None],
                   "C": [False, None, False, True]}) # 创建一个包含不同数据类型和缺失值的 DataFrame
df # 显示 DataFrame

df["A"] = df["A"].astype("Int64") # 将 "A" 列转换为可空整数类型
df["B"] = df["B"].astype("string") # 将 "B" 列转换为专门的字符串类型
df["C"] = df["C"].astype("boolean") # 将 "C" 列转换为可空布尔类型
df # 显示 DataFrame

val = "a,b,  guido" # 定义一个包含逗号分隔符和空格的字符串
val.split(",") # 使用 .split(",") 方法将字符串拆分为列表

pieces = [x.strip() for x in val.split(",")] # 使用列表推导式和 .strip() 方法去除每个子字符串两侧的空格
pieces # 显示结果列表

first, second, third = pieces # 将列表中的元素解包到变量中
first + "::" + second + "::" + third  # 使用 + 运算符连接字符串

"::".join(pieces) # 使用 .join() 方法连接字符串，更 Pythonic 的方式

"guido" in val # 使用 in 运算符检查字符串中是否包含子字符串

val.index(",")  # 使用 .index() 方法查找子字符串的索引，如果未找到则引发 ValueError 异常

val.find(":")   # 使用 .find() 方法查找子字符串的索引，如果未找到则返回 -1

val.count(",") # 使用 .count() 方法计算子字符串出现的次数

val.replace(",", "::") # 使用 .replace() 方法将子字符串替换为另一个字符串

val.replace(",", "")  # 通过替换为空字符串来删除子字符串

import re # 导入 re 模块
text = "foo    bar\t baz  \tqux" # 定义一个包含不同空白字符分隔的字符串
re.split(r"\s+", text)  # 使用 re.split() 和正则表达式 "\s+" 将字符串拆分为列表，"\s+" 匹配一个或多个空白字符

regex = re.compile(r"\s+")  # 使用 re.compile() 编译正则表达式，创建一个可重用的正则表达式对象
regex.split(text) # 使用编译后的正则表达式对象拆分文本

regex.findall(text) # 使用 .findall() 方法查找字符串中所有匹配正则表达式的子字符串

text = """Dave [email protected]
Steve [email protected]
Rob [email protected]
Ryan [email protected]""" # 定义一个包含多个电子邮件地址的字符串

pattern = r"[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}"  # 用于匹配电子邮件地址的基本正则表达式

# re.IGNORECASE 使正则表达式不区分大小写
regex = re.compile(pattern, flags=re.IGNORECASE) # 编译正则表达式，并设置 re.IGNORECASE 标志以忽略大小写

regex.findall(text) # 使用 .findall() 方法查找字符串中所有匹配正则表达式的电子邮件地址

m = regex.search(text) # 使用 .search() 方法查找字符串中第一个匹配正则表达式的子字符串
m # 显示匹配对象

text[m.start():m.end()] # 使用匹配对象的 .start() 和 .end() 方法获取匹配子字符串在原始字符串中的位置

print(regex.sub("REDACTED", text)) # 使用 .sub() 方法将匹配正则表达式的子字符串替换为另一个字符串

pattern = r"([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})"  # 带有捕获组的正则表达式
regex = re.compile(pattern, flags=re.IGNORECASE) # 编译正则表达式，并设置 re.IGNORECASE 标志

m = regex.match("[email protected]") # 使用 .match() 方法匹配字符串的开头
m.groups() # 使用 .groups() 方法获取捕获组的内容

regex.findall(text) # 当正则表达式包含捕获组时，.findall() 方法返回一个元组列表，每个元组包含捕获组的内容

print(regex.sub(r"Username: \1, Domain: \2, Suffix: \3", text)) # 在 .sub() 方法中，可以使用 \1、\2 等引用捕获组

data = {"Dave": "[email protected]", "Steve": "[email protected]",
        "Rob": "[email protected]", "Wes": np.nan} # 创建一个包含电子邮件地址和缺失值的字典
data = pd.Series(data) # 将字典转换为 Series
data # 显示 Series

data.isna() # 检查缺失值

data.str.contains("gmail") # 使用 .str.contains() 方法检查每个字符串是否包含 "gmail"

pattern = r"([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})" # 定义用于匹配电子邮件地址的正则表达式
data.str.findall(pattern, flags=re.IGNORECASE) # 将正则表达式与 .str.findall() 方法一起使用，并设置 re.IGNORECASE 标志

matches = data.str.findall(pattern, flags=re.IGNORECASE).str[0] # 使用 .str.findall() 查找匹配项，然后使用 .str[0] 获取第一个匹配项
matches # 显示匹配项

matches.str.get(1) # 使用 .str.get(1) 访问匹配项的第二个元素

data.str[:5]  # 字符串切片

data.str.extract(pattern, flags=re.IGNORECASE) # 使用 .str.extract() 方法提取捕获组，每个捕获组成为 DataFrame 中的一列

values = pd.Series(['apple', 'orange', 'apple',
                    'apple'] * 2) # 创建一个包含重复字符串的 Series
values # 显示 Series

pd.unique(values) # 使用 pd.unique() 获取 Series 中的唯一值

pd.value_counts(values) # 使用 pd.value_counts() 统计每个唯一值的出现次数

values = pd.Series([0, 1, 0, 0] * 2) # 创建一个包含整数键的 Series
dim = pd.Series(['apple', 'orange']) # 创建一个维度表 Series
values # 显示整数键 Series

dim # 显示维度表

dim.take(values) # 使用 .take() 方法和整数键从维度表中恢复原始字符串 Series

fruits = ['apple', 'orange', 'apple', 'apple'] * 2 # 创建一个水果列表
N = len(fruits) # 计算列表长度
rng = np.random.default_rng(seed=12345) # 创建一个随机数生成器，并设置种子以确保结果可重复
df = pd.DataFrame({'fruit': fruits,
                   'basket_id': np.arange(N),
                   'count': rng.integers(3, 15, size=N),
                   'weight': rng.uniform(0, 4, size=N)},
                  columns=['basket_id', 'fruit', 'count', 'weight']) # 创建一个 DataFrame
df # 显示 DataFrame

fruit_cat = df['fruit'].astype('category') # 使用 .astype('category') 将 "fruit" 列转换为 Categorical 类型
fruit_cat # 显示转换后的 Series

c = fruit_cat.array # 使用 .array 属性访问底层的 Categorical 对象
type(c) # 查看对象的类型

c.categories # 查看 Categorical 对象的类别

c.codes # 查看 Categorical 对象的代码

df['fruit'] = df['fruit'].astype('category') # 将 DataFrame 的 "fruit" 列转换为 Categorical 类型
df["fruit"] # 显示转换后的列

my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar']) # 直接从 Python 序列创建 Categorical 对象
my_categories # 显示 Categorical 对象

categories = ['foo', 'bar', 'baz'] # 定义类别
codes = [0, 1, 2, 0, 0, 1] # 定义代码
my_cats_2 = pd.Categorical.from_codes(codes, categories) # 使用 .from_codes() 构造函数从代码和类别创建 Categorical 对象
my_cats_2 # 显示 Categorical 对象

ordered_cat = pd.Categorical.from_codes(codes, categories,
                                        ordered=True) # 使用 ordered=True 参数创建有序 Categorical 对象
ordered_cat # 显示有序 Categorical 对象

my_cats_2.as_ordered() # 使用 .as_ordered() 方法将无序 Categorical 对象转换为有序

rng = np.random.default_rng(seed=12345) # 创建一个随机数生成器
draws = rng.standard_normal(1000) # 生成 1000 个标准正态分布的随机数
draws[:5] # 显示前 5 个随机数

bins = pd.qcut(draws, 4) # 使用 pd.qcut() 将数据分成四分位数
bins # 显示分箱结果，返回一个 Categorical 对象

bins = pd.qcut(draws, 4, labels=['Q1', 'Q2', 'Q3', 'Q4']) # 使用 labels 参数为四分位数添加标签
bins # 显示带有标签的分箱结果

bins.codes[:10] # 查看前 10 个数据对应的分位数代码

bins = pd.Series(bins, name='quartile') # 将分箱结果转换为 Series，并命名为 "quartile"
results = (pd.Series(draws) # 将原始数据转换为 Series
           .groupby(bins) # 使用分箱结果进行分组
           .agg(['count', 'min', 'max']) # 对每个分组计算数量、最小值和最大值
           .reset_index()) # 重置索引
results # 显示结果

results['quartile'] # 查看结果中的 "quartile" 列，保留了原始的 Categorical 信息

N = 10_000_000 # 定义数据量
labels = pd.Series(['foo', 'bar', 'baz', 'qux'] * (N // 4)) # 创建一个包含重复字符串的 Series
categories = labels.astype('category') # 将 Series 转换为 Categorical 类型

labels.memory_usage(deep=True) # 查看原始 Series 的内存使用情况

categories.memory_usage(deep=True) # 查看 Categorical 类型的 Series 的内存使用情况

s = pd.Series(['a', 'b', 'c', 'd'] * 2) # 创建一个包含重复字符串的 Series
cat_s = s.astype('category') # 将 Series 转换为 Categorical 类型
cat_s # 显示 Categorical Series

cat_s.cat.codes # 使用 .cat.codes 访问 Categorical 对象的代码

cat_s.cat.categories # 使用 .cat.categories 访问 Categorical 对象的类别

actual_categories = ['a', 'b', 'c', 'd', 'e'] # 定义新的类别
cat_s2 = cat_s.cat.set_categories(actual_categories) # 使用 .cat.set_categories() 方法设置新的类别
cat_s2 # 显示新的 Categorical Series

cat_s.value_counts() # 统计原始 Categorical Series 中每个类别的出现次数

cat_s2.value_counts() # 统计新的 Categorical Series 中每个类别的出现次数，即使某些类别在数据中不存在也会显示

cat_s3 = cat_s[cat_s.isin(['a', 'b'])] # 筛选出只包含类别 "a" 和 "b" 的数据
cat_s3 # 显示筛选后的 Categorical Series

cat_s3.cat.remove_unused_categories() # 使用 .cat.remove_unused_categories() 方法删除未使用的类别

cat_s = pd.Series(['a', 'b', 'c', 'd'] * 2, dtype='category') # 创建一个 Categorical Series
pd.get_dummies(cat_s) # 使用 pd.get_dummies() 函数将 Categorical Series 转换为虚拟变量