Pandas6(数据清洗2)——置换和随机采样、get_dummies、扩展数据类型、字符串处理函数

数据清洗2

一、置换和随机采样(permutation,sample)

  1. 随机置换(打乱排序(洗牌))函数:numpy.random.permutation ,可以对一个序列进行随机排序,常用于数据集随机划分等场景

    np.random.permutation(x):如果x是一个整数n,它会返回一个打乱的0到n-1的整数数组(可以看成一个打乱的位置索引)
    如果x是一个数组,它会返回一个打乱顺序后的新数组

print(np.random.permutation(5))
# 输出 [1 2 0 3 4]

arr = np.array(['cat', 'dog', 'bird', "fish"])
print(np.random.permutation(arr))
# 输出: ['bird' 'fish' 'cat' 'dog']

df = pd.DataFrame(np.arange(5*7).reshape((5,7)))
sampler = np.random.permutation(5)
df.take(sampler) # take()函数默认是行索引,因此再此处就是将df的行索引顺序设置成为打乱后的行索引
sampler = np.random.permutation(7)
df.take(sampler,axis="columns") # 对列索引进行打乱
  1. 随机采样函数:sample()
  • 默认随机抽取是无放回的抽样(抽样结果中一定没有重复的抽样数据),将replace 设置为True则会变成有放回的抽样(抽样结果中可能有重复的数据)
  • weight: 设置每行/每列被取到的权重比
# 无放回抽样 (默认)
sample = df.sample(n=3)  # 抽取3行
sample = df.sample(frac=0.6)  # 抽取60%的数据

# 有放回抽样
sample_with_replacement = df.sample(n=10, replace=True)  # 抽取10行,可能有重复

# 根据权重列抽样
weights = [0.1, 0.2, 0.3, 0.2, 0.2]
weighted_sample = df.sample(n=2, weights=weights)

二、计算分类编码(get_dummies

get_dummies()是Pandas中用于执行独热编码(One-Hot Encoding)的函数,它将分类变量/特征转换为机器学习算法更易处理的数值形式

  • data: 要转换的数据(Series/DataFrame)
  • prefix: 为生成的列添加前缀
  • prefix_sep: 前缀分隔符(默认为"_")
  • dummy_na: 是否创建NaN的指示列(默认为False)
  • columns: 指定要转换的列(当输入是DataFrame时)
  • drop_first: 是否删除第一个类别(避免多重共线性)
  • dtype: 输出数据类型(默认为uint8)
import pandas as pd

# 示例数据
df = pd.DataFrame({
    '颜色': ['红', '蓝', '绿', '蓝', '红'],
    '尺寸': ['大', '中', '小', '大', '中']
})
df
# 基本编码
pd.get_dummies(df) # 生成将df中每个列名中的唯一的数据作为列名,的独特编码的dataframe
pd.get_dummies(df["尺寸"]).replace({True:1, False:0}) # 生成将df["尺寸"]中的数据作为列名的独特编码的dataframe
pd.get_dummies(df, prefix=['col', 'size']) # 自定义前缀
# 设置nan列
df.loc[2, '颜色'] = None
pd.get_dummies(df, dummy_na=True)

三、pandas扩展数据类型(Int8Dtype 、BooleanDtype、StringDtype、category

pandas原本建立在Numpy功能之上,所以数据类型沿用的numpy,这有一些问题:

  • 整数,布尔值的缺失值被当成浮点数,导致不易察觉的问题

  • 含有大量字符串数据时,计算开销大,同时占用很多内存

  • 日期数据类型、稀疏数据的处理问题

  • 因此派生出pandas扩展数据类型:

    • pd.Int8Dtype / pd.Int16Dtype 替代 int数据类型
    • pd.BooleanDtype 替代 bool数据类型
    • pd.StringDtype 代替 object 数据类型,可被认为数string处理
    s = pd.Series([1,2,3,None])	# 缺失值显示NAN
    s.dtype     				# 显示float64  nan解析成小数,但本质是想要整数的数据类型
    # 用pandas的数据类型创建它,dtype执行,series的数据类型
    s = pd.Series([1,2,3,None], dtype=pd.Int64Dtype())  # 缺失值显示<NA>表示整数类型的缺失值
    s.dtype    #  Int64Dtype()  代替int64,这种扩展的类型支持带有缺失值的整数类型
    
    s = pd.Series(["one", "two", None, "three"])
    s.dtype		# 显示object类型
    s = pd.Series(["one", "two", None, "three"], dtype=pd.StringDtype())
    s.dtype		# 显示StringDtype类型,将所有数据优先认为str处理
    
    s = pd.Series([True, False, None])
    s.dtype  #  dtype('O')  表示数据类型为对象。这通常意味着该列包含字符串或混合类型的数据。但想要的是bool类型,只是包含了一个缺失值而已
    s = pd.Series([True, False, None], dtype=pd.BooleanDtype())
    s.dtype  # BooleanDtype,代替bool类型,支持由有缺失值的bool类型
    
    
    
    • pd.CategoricalDtype(简写就是category) 分类数据类型,在groupby、sort、value_counts 等操作中比 object 类型更快。
    • 其他的(暂时还没用到)
    # 创建自定义的数据dataframe
    fruits = ["apple", "orange", "apple", "apple"] * 10
    N = len(fruits)
    rng = np.random.default_rng(seed=100)
    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']
                      )
    # 查看category 和普通的 object 类型数据的差异
    print(df.info())  # 内存占用memory usage: 11.1+ KB
    df = df.astype(dtype={'fruit': 'category', 'weight': 'category'})
    print(df.info())  # 内存占用memory usage: 5.8 KB
    df["fruit"] = df["fruit"].cat.add_categories(["other"])  # 动态增加fruit类别
    print(df["fruit"])
    df["fruit"].cat.remove_unused_categories() # 删除没用在数据表中的类别
    
    
    
    
    # 创建分类对象1:可以从其他python序列直接创建 pd.Categorical,传入的是类别值(未被分类的数据)
    my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar'])
    my_categories
    
    # 创建分类对象2:已经获取了数据的分类编码 和 具体类别,可以用from_codes把数据的分类编码转成对应类别
    categories = ["foo", "bar", "baz"]
    codes = [0, 1, 2, 0, 0, 1]
    my_cats_2 = pd.Categorical.from_codes(codes, categories)
    my_cats_2
    
    # 注意:默认分类没有顺序,from_codes通过ordered参数指定为True可以指定数学上的顺序
    ordered_cat = pd.Categorical.from_codes(codes, categories, ordered=True)
    ordered_cat  # foo<bar<baz,ordered=True 不是"允许比较",而是"声明这些类别有真实顺序关系,请按我定义的顺序处理比较和排序"。就像告诉Pandas:"这些不是随便的标签,它们是有实际意义的等级/大小
    # 使用了ordered = True之后,原本的series就拥有了部分数字的功能,能够对其使用一些数学函数
    my_cats_2.as_ordered()  # 对无序的分类对象通过as_ordered排序  。相当于 pandas_categorical的实例.as_ordered()
    
%timeit (测量代码的执行时间) %prun(性能分析)或 %memit(内存测量)魔法命令使用

四、采用正则表达式处理字符串

正则表达式
  提供在文本中搜索和匹配字符串模式的灵活方式, 正则表达式常称作regex,是根据正则表达式语言编写的字符串
  python的re模块负责对字符串应用正则表达式
  re模块的函数可以分为三类:
	  模式匹配:  findall(返回所有匹配的子串列表),  search(扫描整个字符串查找匹配,返回第一个符合条件的子串),   match(只匹配出现在字符串开始位置的模式,开始不符合就直接返回none);
	  替换: sub(替换值,原始值:替换匹配字符串), subn, 
	  拆分: split; regex描述的是在文本中定位的模式
	  
  • 使用re.compile() 将正则表达式字符串编译成一个正则表达式对象,可以用于匹配字符串
    # import re
    text = """Dave dave@google.com
    Steve steve@gmail.com
    Rob rob@gmail.com
    Ryan ryan@yahoo.com"""
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
    pattern = r"[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}"  # 识别电子邮件地址的正则表达式
    regex = re.compile(pattern, flags=re.IGNORECASE) # flags设置的参数表示正则表达式不区分大小写
    
    
为什么要用 re.compile?
	提高效率:如果同一个正则表达式需要多次使用,编译后可以避免重复解析正则表达式字符串。
	代码更清晰:编译后的对象可以复用,使代码更模块化。
	支持更多操作:编译后的对象可以直接调用 match()、search()、findall() 等方法。

五、字符串操作

  • python字符串对象的内置方法能轻松完成大部分文本运算, 对于更复杂的模式匹配和文本操作,则可能需要用到正则表达式
  • pandas基于python的字符串方法,做了加强,能够对整组数据应用字符串方法和正则表达式,处理缺失数据

1、字符串分割与拼接

  • str.split(sep, n=-1, expand=False) : 按指定分隔符(sep)分割字符串,n 控制分割次数,expand=True 返回 DataFrame。
  • str.rsplit(sep, n=-1, expand=False) : 从右侧开始分割字符串。
  • str.join(iterable) : 用指定字符串连接序列中的元素。
  • str.cat(others=None, sep=None, na_rep=None) : 拼接字符串,支持与其他 Series 或列表拼接。
    df["Name"].str.split(",", expand=True)  # 分割成多列
    df["Words"].str.join("-")  # 将列表中的字符串用 "-" 连接
    df["First"].str.cat(df["Last"], sep=" ")  # 合并两列
    

2、字符串匹配与提取

  • str.contains(pat, case=True, regex=True) : 检查字符串是否包含指定模式(支持正则表达式)。

  • str.match(pat, case=True) : 检查字符串是否以指定模式开头(正则表达式)。

  • str.find(sub) / str.rfind(sub) : 返回子字符串的首次/最后一次出现位置(未找到返回 -1)。

    df["fruit"].str.contains("apple|orange", case=False)  # 不区分大小写
    df["fruit"].str.match("a") # 是否以a字母开头
    df["fruit"].str.find("p")   # apple中返回1
    df["fruit"].str.rfind("p")  # apple中返回2
    

3、字符串替换

  • str.replace(pat, repl, regex=True) : 替换字符串中的模式(支持正则表达式)。

  • str.strip(to_strip=None) / str.lstrip() / str.rstrip() : 去除字符串两端的空白字符(或指定字符)。

  • str.translate(table) : 接受一个字典作为参数,字典的键是要替代的字符的Unicode码,值是相应的映射字Unicode码。

      df["Phone"].str.replace(r'\D', '', regex=True)  # 移除非数字字符
      ord("a") # 97
      chr(98) # 'b'
      df["fruit"].str.translate({97: 98}) # 将字符串中的a转化成b
    

4、字符串格式化与填充

  • str.lower() / str.upper() / str.title() / str.capitalize() : 转换大小写

  • str.pad(width, side='left', fillchar=' ') : 填充字符串到指定长度。

    df["Name"].str.title()  # 首字母大写
    df["ID"].str.pad(5, side="left", fillchar="0")  # 左填充 0
    
  • str.zfill(width) : 用 0 左填充字符串(类似 pad 但固定填充 0)。

5、字符串长度与索引

  • str.len() : 返回字符串长度。

  • str.get(i) : 获取字符串的第 i 个字符(类似 Python 的索引)。

  • str.slice(start, stop, step) : 切片操作(类似 Python 的字符串切片)。

    df["Text"].str.len()  # 计算每个字符串的长度
    df["Code"].str.get(0)  # 获取第一个字符
    df["Date"].str.slice(0, 4)  # 提取前 4 个字符(年份)
    

6、字符串判断

  • str.isalpha() / str.isnumeric() / str.isalnum() : 检查字符串是否全为字母/数字/字母或数字。

  • str.startswith(pat) / str.endswith(pat) : 检查字符串是否以指定模式开头或结尾。

    df["URL"].str.endswith(".com")
    df["Password"].str.isalnum()  # 是否只含字母和数字
    

7、其他实用方法

  • str.wrap(width, **kwargs) : 自动换行(按指定宽度分割字符串)。

  • str.repeat(n) : 重复字符串 n 次。

  • str.count(pat) : 统计子字符串出现的次数。

    df["Sentence"].str.count("the")  # 统计 "the" 出现次数
    df["Symbol"].str.repeat(3)  # 如 "A" → "AAA"
    

总结

  • 数据清洗,准备工作做的好可以让数据分析过程更顺畅,提高生产力
  • 数据清洗: 缺失值处理, 重复值删除,数据转换和替换,检测和过滤异常值
  • 数据准备: 重命名轴索引,分箱, 数据重排和采样,pandas扩展类型, 分类类型,字符串方法
内容概要:本文探讨了在MATLAB/SimuLink环境中进行三相STATCOM(静态同步补偿器)无功补偿的技术方法及其仿真过程。首先介绍了STATCOM作为无功功率补偿装置的工作原理,即通过调节交流电压的幅值相位来实现对无功功率的有效管理。接着详细描述了在MATLAB/SimuLink平台下构建三相STATCOM仿真模型的具体步骤,包括创建新模型、添加电源负载、搭建主电路、加入控制模块以及完成整个电路的连接。然后阐述了如何通过对STATCOM输出电压电流的精确调控达到无功补偿的目的,并展示了具体的仿真结果分析方法,如读取仿真数据、提取关键参数、绘制无功功率变化曲线等。最后指出,这种技术可以显著提升电力系统的稳定性与电能质量,展望了STATCOM在未来的发展潜力。 适合人群:电气工程专业学生、从事电力系统相关工作的技术人员、希望深入了解无功补偿技术的研究人员。 使用场景及目标:适用于想要掌握MATLAB/SimuLink软件操作技能的人群,特别是那些专注于电力电子领域的从业者;旨在帮助他们学会建立复杂的电力系统仿真模型,以便更好地理解STATCOM的工作机制,进而优化实际项目中的无功补偿方案。 其他说明:文中提供的实例代码可以帮助读者直观地了解如何从零开始构建一个完整的三相STATCOM仿真环境,并通过图形化的方式展示无功补偿的效果,便于进一步的学习与研究。
### pandas `get_dummies` 函数详解 #### 基本功能描述 `pandas.get_dummies` 是 Pandas 库中的一个重要工具,主要用于处理分类数据。此函数可以将分类变量转换成哑变量(也称为指示变量)。通过这种方式,每个类别的存在与否被表示为二进制值 0 或者 1 的新列[^1]。 #### 参数说明 - **data**: 输入的数据结构,通常是 Series 或 DataFrame 类型。 - **prefix**: 字符串字符串列表,作为生成的新列名前缀,默认情况下会自动根据原始列名称加上下划线。 - **prefix_sep**: 新列名字之间的分隔符,默认是下划线 `_`. - **dummy_na**: 如果设为 True,则缺失值也会被视为有效的特征并创建对应的虚拟变量;默认为 False. - **columns**: 需要进行独热编码的具体列名组成的列表,如果未指定则会对所有的非数值类型的列执行操作。 - **sparse**: 是否返回稀疏矩阵形式的结果,默认不启用。 - **drop_first**: 若设置为 True 则移除第一个水平以减少冗余度,防止完全共线性问题的发生。 - **dtype**: 设置输出的 dtype 数据类型,默认无特殊设定即保持原样。 #### 实际应用案例展示 为了更好地理解如何使用这个函数,在这里给出一个具体的例子: 假设有一个关于学生的简单表格如下所示: ```python import pandas as pd students_df = pd.DataFrame({ 'Id': [302, 504, 708, 103, 303], 'Name': ["Mike", "Christine", "Rob", "Daniel", "Jennifer"], 'Sex': ['Male', 'Female', 'Male', 'Male', 'Female'], }) ``` 现在想要仅针对性别这一栏做独热编码转换,可以通过以下方式实现: ```python students_df_dummies = pd.get_dummies(students_df, columns=["Sex"]) print("Original Dataframe:") print(students_df) print("\nDataframe after applying get_dummies on column Sex:") print(students_df_dummies) ``` 这段代码将会把原有的 `Sex` 列拆分成两个新的布尔列——分别是 `Sex_Female` `Sex_Male`,其中每一行对应位置上的值取决于原来那里的性别标签是什么样的[^4].
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值