• Pandas-04（缺失数据、分组、合并连接、级联）

    目录

    1.缺失数据

    1.1 isnull()和notnull()检测缺失数据

    1.2 fillna()填充缺失值

    1.3 删除NaN的行 

    1.4 replace()替换丢失的值或者通用值

    2. 分组 

    2.1 groupby（）分组

    2.2 get_group()选择组

    3.合并连接merge()

    3.1  示例

    3.2  merge()合并

    3.3  合并模式

    4.级联concat()

    1.缺失数据

    由于数据有多种形式和形式，pandas 旨在灵活处理缺失数据。虽然NaN出于计算速度和方便的原因，它是默认的缺失值标记，但我们需要能够使用不同类型的数据轻松检测该值：浮点、整数、布尔值和一般对象。然而，在许多情况下，PythonNone会出现，我们也希望考虑“缺失”或“不可用”或“NA”。

    1.1 isnull()和notnull()检测缺失数据

    为了更容易检测缺失值（以及跨不同的数组 dtype），pandas 提供了isnull()和notnull()函数，它们也是 Series 和 DataFrame 对象的方法：

    1. isnull()

    示例：

    1. import pandas as pd
    2. import numpy as np
    3.  
    4. df = pd.DataFrame(np.random.randn(5,3),index=['a','c','e','f','h'],columns=['one','two','three'])
    5. df = df.reindex(['a','b','c','d','e','f','h'])
    6.  
    7. df
    8.  
    9.  
    10. # 输出结果：
    11.          one	    two	      three
    12. a	-0.864969	0.299120	-0.936382
    13. b	     NaN	     NaN	     NaN
    14. c	1.573142	-2.359139	0.118325
    15. d	     NaN	     NaN	     NaN
    16. e	1.070140	-0.392129	-0.647714
    17. f	-0.886120	-0.926900	1.170801
    18. h	0.725739	1.182897	-0.899262
    1. #检查缺失数据
    2. df[df['one'].isnull()] 
    3.  
    4.  
    5. # 输出结果：
    6. 	one	 two	three
    7. b	NaN	 NaN	NaN
    8. d	NaN  NaN	NaN

    2. notnull()

    1. #检查是不是非空的
    2. df['one'].notnull()
    3.  
    4.  
    5. # 输出结果：
    6. a     True
    7. b    False
    8. c     True
    9. d    False
    10. e     True
    11. f     True
    12. h     True
    13. Name: one, dtype: bool

    输出非空结果：

    1. df[df['one'].notnull()]
    2.  
    3. # 输出结果：
    4.           one	    two	     three
    5. a	-0.864969	0.299120	-0.936382
    6. c	1.573142	-2.359139	0.118325
    7. e	1.070140	-0.392129	-0.647714
    8. f	-0.886120	-0.926900	1.170801
    9. h	0.725739	1.182897	-0.899262

    1.2 fillna()填充缺失值

    finall()可以通过几种方式用非 NA 数据“填充”NA 值。

    1.将NA值替换为标量值

    指定列内容[colomns]填充content：

    df["colomns"].fillna("content")

    2.向前或向后填补空白

    可以指定method的方法pad向前填充值或使用bfill向后填充值：

    df.fillna(method="pad")

    3. 限制填充量

    当只想连续填充一定数量的数据点，可以使用limit关键字：

    df.fillna(method="pad", limit=1)

    4.示例：

    1.  #  df数据
    2.        one	       two	       three
    3. a	-0.864969	0.299120	-0.936382
    4. b	NaN	NaN	NaN
    5. c	1.573142	-2.359139	0.118325
    6. d	NaN	NaN	NaN
    7. e	1.070140	-0.392129	-0.647714
    8. f	-0.886120	-0.926900	1.170801
    9. h	0.725739	1.182897	-0.899262
    1. #可以填充我们想要的数据
    2. df.fillna(df.mean())
    3.  
    4. #输出结果：
    5. one	two	three
    6. a	-0.864969	0.299120	-0.936382
    7. b	0.323586	-0.439230	-0.238846
    8. c	1.573142	-2.359139	0.118325
    9. d	0.323586	-0.439230	-0.238846
    10. e	1.070140	-0.392129	-0.647714
    11. f	-0.886120	-0.926900	1.170801
    12. h	0.725739	1.182897	-0.899262
    13.  
    14.  
    15. #将前面的数据填充进来
    16. df.fillna(method='pad') 
    17.  
    18. #输出结果：
    19. one	two	three
    20. a	-0.864969	0.299120	-0.936382
    21. b	-0.864969	0.299120	-0.936382
    22. c	1.573142	-2.359139	0.118325
    23. d	1.573142	-2.359139	0.118325
    24. e	1.070140	-0.392129	-0.647714
    25. f	-0.886120	-0.926900	1.170801
    26. h	0.725739	1.182897	-0.899262
    27.  
    28.  
    29. #将后面的数据填充进来
    30. df.fillna(method='backfill')
    31.  
    32. #输出结果 ：
    33. one	two	three
    34. a	-0.864969	0.299120	-0.936382
    35. b	1.573142	-2.359139	0.118325
    36. c	1.573142	-2.359139	0.118325
    37. d	1.070140	-0.392129	-0.647714
    38. e	1.070140	-0.392129	-0.647714
    39. f	-0.886120	-0.926900	1.170801
    40. h	0.725739	1.182897	-0.899262
    41.  
    42.

      1.3 删除NaN的行 

    df.dropna() #删除有NAN的行

    示例：

    1. #删除有NAN的行
    2. df.dropna() 
    3.  
    4. #输出结果：
    5. one	two	three
    6. a	-0.864969	0.299120	-0.936382
    7. c	1.573142	-2.359139	0.118325
    8. e	1.070140	-0.392129	-0.647714
    9. f	-0.886120	-0.926900	1.170801
    10. h	0.725739	1.182897	-0.899262

     1.4 replace()替换丢失的值或者通用值

    replace({nan:替换值})

    示例：

    1. df.replace({np.nan:10})
    2.  
    3. # 输出结果：
    4.        one	       two	      three
    5. a	-0.864969	0.299120	-0.936382
    6. b	10.000000	10.000000	10.000000
    7. c	1.573142	-2.359139	0.118325
    8. d	10.000000	10.000000	10.000000
    9. e	1.070140	-0.392129	-0.647714
    10. f	-0.886120	-0.926900	1.170801
    11. h	0.725739	1.182897	-0.899262
    12.  
    13.  
    14. df['four']=pd.Series([1,2,3,4,5,6,7],index=['a','b','c','d','e','f','h'])
    15. df
    16. #输出结果：
    17.         one	       two	       three	four
    18. a	-0.864969	0.299120	-0.936382	 1
    19. b	     NaN	      NaN	      NaN	 2
    20. c	1.573142	-2.359139	0.118325	 3
    21. d	     NaN	      NaN	      NaN	 4
    22. e	1.070140	-0.392129	-0.647714	 5
    23. f	-0.886120	-0.926900	1.170801	 6
    24. h	0.725739	1.182897	-0.899262	 7
    25.  
    26. #替换NaN为10，5为1000
    27. df.replace({np.nan:10,5:1000})
    28.  
    29. #输出结果：
    30.          one	     two	   three	four
    31. a	-0.864969	0.299120	-0.936382	1
    32. b	10.000000	10.000000	10.000000	2
    33. c	1.573142	-2.359139	0.118325	3
    34. d	10.000000	10.000000	10.000000	4
    35. e	1.070140	-0.392129	-0.647714	1000
    36. f	-0.886120	-0.926900	1.170801	6
    37. h	0.725739	1.182897	-0.899262	7

     

    2. 分组 

    pandas 对象可以在它们的任何轴上分割。分组的抽象定义是提供标签到组名的映射。

    “分组依据”是指涉及以下一个或多个步骤的过程：

    • 根据某些标准将数据分组。

    • 独立地对每个组应用一个函数。

    • 将结果组合成一个数据结构。

    其中，拆分步骤是最直接的。事实上，在许多情况下，我们可能希望将数据集分成组，并对这些组做一些事情。

    2.1 groupby（）分组

    示例：

    1. import pandas as pd
    2. import numpy as np
    3.  
    4. df = pd.DataFrame({
    5.     'user':['小明',"小黑",'小黄','小李'],
    6.     'gender':['男','女','女','男'],
    7.     'score':[99,95,70,88]
    8. })
    9.  
    10. df
    11.  
    12. #输出结果：
    13. 	user	gender	score
    14. 0	小明	 男	      99
    15. 1	小黑	 女	      95
    16. 2	小黄	 女	      70
    17. 3	小李	 男	      88

    1.进行分组

    1. #分组对象
    2. df.groupby('gender')
    3.  
    4. #输出结果：
    5. <pandas.core.groupby.groupby.DataFrameGroupBy object at 0x000001FA94C1A400>

     2.获取分组情况

    1. df.groupby('gender').groups#获取分组情况
    2.  
    3. #输出结果：
    4. {'女': Int64Index([1, 2], dtype='int64'),
    5.  '男': Int64Index([0, 3], dtype='int64')}

    3. 循环迭代组

    1. #循环迭代组
    2. grouped = df.groupby('gender')
    3. for name,group in grouped:
    4.     print(name)
    5.     print(group)
    6.  
    7. #输出结果：
    8.  女
    9.      user gender  score
    10. 1   小黑      女     95
    11. 2   小黄      女     70
    12.  男
    13.      user gender  score
    14. 0   小明      男     99
    15. 3   小李      男     88

    2.2 get_group()选择组

    1. get_group()基础使用

    1. #选择组
    2. grouped.get_group('男')
    3.  
    4. #输出结果：
    5. 	user	gender	score
    6. 0	小明	  男	   99
    7. 3	小李	  男	   88
    8.  
    9.  
    10. #选择组，聚合计算
    11. grouped.get_group('男')['score'].agg(np.mean)
    12. grouped.get_group('女')['score'].agg(np.max)
    13.  
    14. #输出结果：
    15. 93.5
    16. 95
    17.  
    18. #获取分组里的长度（）
    19. grouped.get_group('女').agg(np.size)
    20.  
    21. #输出结果：
    22. user      2
    23. gender    2
    24. score     2
    25. dtype: int64

     2.分组聚合

    1. df['star'] = pd.Series([5,7,4,3])
    2. df
    3.  
    4. #输出结果：
    5. 	user	gender	score	star
    6. 0	小明	  男	  99	 5
    7. 1	小黑	  女	  95	 7
    8. 2	小黄	  女	  70	 4
    9. 3	小李	  男	  88	 3
    10.  
    11.  
    12. grouped = df.groupby('gender')
    13. #求男女平均分及星数总和
    14. grouped[['score','star']].agg({'score':np.mean,'star':np.sum})
    15.  
    16. #输出结果：
    17. 	    score	star
    18. gender		
    19. 女    	82.5	11
    20. 男	    93.5	8
    21.  
    22.  
    23. #分组中平均分大于90的
    24. df.groupby('gender').filter(lambda x:x['score'].mean()>90)
    25.  
    26. #输出结果：
    27. 	user	gender	score	star
    28. 0	小明	   男	  99	5
    29. 3	小李	  男	  88	3

    3.合并连接merge()

    在pandas中，可以使用merge()对多个数据进行合并，基础语法如下：

    pd.merge(df1,df2...,on='合并索引值')

    3.1 示例

    1. import pandas as pd
    2. import numpy as np
    3.  
    4. yuwen = pd.DataFrame({
    5.     'id':[1,2,3,4,5,7],
    6.     'name':["小明","小敏","小红","小黑","小王",'老陈'],
    7.     'yuwenScore':[98,77,45,87,66,99]
    8.     
    9. })
    10.  
    11. shuxue = pd.DataFrame({
    12.     'id':[1,2,3,4,5,6],
    13.     'name':["小明","小敏","小红","小黑","小王","老李"],
    14.     'shuxueScore':[79,56,88,92,68,88]
    15.     
    16. })
    17.  
    18. #  输出结果
    19. 	id	name	yuwenScore
    20. 0	1	小明	98
    21. 1	2	小敏	77
    22. 2	3	小红	45
    23. 3	4	小黑	87
    24. 4	5	小王	66
    25. 5	7	老陈	99
    26.  
    27.  
    28. 	id	name	shuxueScore
    29. 0	1	小明	79
    30. 1	2	小敏	56
    31. 2	3	小红	88
    32. 3	4	小黑	92
    33. 4	5	小王	68
    34. 5	6	老李	88

    3.2  merge()合并

    1. pd.merge(yuwen,shuxue,on='id')#通过id这个健合并
    2.  
    3. #输出结果：
    4.    id	name_x	yuwenScore	name_y	shuxueScore
    5. 0	1	小明	98	        小明	79
    6. 1	2	小敏	77	        小敏	56
    7. 2	3	小红	45	        小红	88
    8. 3	4	小黑	87	        小黑	92
    9. 4	5	小王	66	        小王	68
    10.  
    11.  
    12. pd.merge(yuwen,shuxue,on=['id','name'])
    13. # 输出结果：
    14. 	id	name	yuwenScore	shuxueScore
    15. 0	1	小明	    98	       79
    16. 1	2	小敏	    77	       56
    17. 2	3	小红	    45     	   88
    18. 3	4	小黑	    87	       92
    19. 4	5	小王	    66	       68

     3. 3 合并模式

    merge()提供how设置合并的方式，inner为键的交集，left为使用左边的键，right为使用右边的键，ourter健的联合。

    示例：

    1. #默认是inner合并模式
    2. pd.merge(yuwen,shuxue,on=['id','name'],how='inner')
    3. # 输出结果
    4.     id	name	yuwenScore	shuxueScore
    5. 0	1	小明	98	        79
    6. 1	2	小敏	77	        56
    7. 2	3	小红	45      	88
    8. 3	4	小黑	87      	92
    9. 4	5	小王	66       	68
    10. ​
    11.  
    12. pd.merge(yuwen,shuxue,on=['id','name'],how='right')
    13. #输出结果
    14. 	id	name	yuwenScore	shuxueScore
    15. 0	1	小明	98.0	    79
    16. 1	2	小敏	77.0	    56
    17. 2	3	小红	45.0	    88
    18. 3	4	小黑	87.0	    92
    19. 4	5	小王	66.0	    68
    20. 5	6	老李	NaN	        88
    21.  
    22. pd.merge(yuwen,shuxue,on=['id','name'],how='outer')
    23. #输出结果
    24.     id	name	yuwenScore	shuxueScore
    25. 0	1	小明	98.0	    79.0
    26. 1	2	小敏	77.0	    56.0
    27. 2	3	小红	45.0	    88.0
    28. 3	4	小黑	87.0	    92.0
    29. 4	5	小王	66.0	    68.0
    30. 5	7	老陈	99.0	    NaN
    31. 6	6	老李	NaN	        88.0
    32.  
    33. pd.merge(yuwen,shuxue,on=['id','name'],how='left')
    34. #输出结果
    35. 	id	name	yuwenScore	shuxueScore
    36. 0	1	小明	98	        79.0
    37. 1	2	小敏	77	        56.0
    38. 2	3	小红	45	        88.0
    39. 3	4	小黑	87	        92.0
    40. 4	5	小王	66	        68.0
    41. 5	7	老陈	99	        NaN

    4.级联concat()

    该concat()函数（在 pandas 主命名空间中）完成了沿轴执行连接操作的所有繁重工作，同时在其他轴上执行索引（如果有）的可选设置逻辑（联合或交集）。

    基础语法：

    1. pd.concat(
    2.     objs,
    3.     axis=0,
    4.     join="outer",
    5.     ignore_index=False,
    6.     keys=None,
    7.     levels=None,
    8.     names=None,
    9.     verify_integrity=False,
    10.     copy=True,
    11. )

    • objs: Series 或 DataFrame 对象的序列或映射。如果传递了 dict，则排序后的键将用作keys参数，除非传递，在这种情况下将选择值（见下文）。任何 None 对象都将被静默删除，除非它们都是 None 在这种情况下将引发 ValueError 。

    • axis: {0, 1, ...}，默认 0。要连接的轴。

    • join: {'inner', 'outer'}，默认为'outer'。如何处理其他轴上的索引。外部用于联合，内部用于交叉。

    • ignore_index：布尔值，默认为 False。如果为 True，则不要使用连接轴上的索引值。结果轴将标记为 0, ..., n - 1。如果您要连接对象，而连接轴没有有意义的索引信息，这将非常有用。请注意，连接中仍然尊重其他轴上的索引值。

    • keys：序列，默认无。使用传递的键作为最外层构建层次索引。如果通过了多个级别，则应包含元组。

    • levels：序列列表，默认无。用于构造 MultiIndex 的特定级别（唯一值）。否则，它们将从密钥中推断出来。

    • names：列表，默认无。生成的分层索引中的级别名称。

    • verify_integrity：布尔值，默认为 False。检查新的连接轴是否包含重复项。相对于实际的数据连接，这可能非常昂贵。

    • copy：布尔值，默认为真。如果为 False，则不要不必要地复制数据。

     示例：

    1. import numpy as np
    2. import pandas as pd
    3.  
    4. one = pd.DataFrame({
    5.     'name':["alex",'xm','xh','lc','ll'],
    6.     'subject':['python','java','go','js','html'],
    7.     'socre':[88,79,68,96,66]
    8. })
    9. two = pd.DataFrame({
    10.     'name':["xc",'xm','xh','lc','ll'],
    11.     'subject':['php','java','go','js','html'],
    12.     'socre':[89,79,68,96,66]
    13. })
    14.  
    15. # 输出结果
    16. 	name	subject	socre
    17. 0	alex	python	88
    18. 1	xm	    java	79
    19. 2	xh    	go	    68
    20. 3	lc	    js	    96
    21. 4	ll   	html	66
    22.  
    23.  
    24.     name	subject	socre
    25. 0	xc	      php	89
    26. 1	xm	     java	79
    27. 2	xh	      go	68
    28. 3	lc	      js	96
    29. 4	ll	     html	66

    忽视索引值合并：

    1. pd.concat([one,two],ignore_index=True)
    2.  
    3. # 输出结果
    4.     name	subject	socre
    5. 0	alex	python	88
    6. 1	xm	    java	79
    7. 2	xh	      go	68
    8. 3	lc	      js	96
    9. 4	ll	     html	66
    10. 5	xc	     php	89
    11. 6	xm	     java	79
    12. 7	xh	      go	68
    13. 8	lc	      js	96
    14. 9	ll	     html	66

     按照列进行合并

    1. #按照列进行合并
    2. pd.concat([one,two],ignore_index=True,axis=1)
    3.  
    4. #输出结果
    5.        0	  1	    2	  3	    4	  5
    6. 0	alex	python	88	  xc	php	  89
    7. 1	xm	    java	79	  xm	java  79
    8. 2	xh	    go	    68	  xh	go	  68
    9. 3	lc	    js	    96	  lc	js	  96
    10. 4	ll	    html	66	  ll	html  66

  • 相关阅读:
    Qwen 通义千问 14B 模型，长文本问答效果测试
    Nginx部署前后端分离项目（Linux）
    Config配置刷新
    10.12作业
    E. Block Sequence-Codeforces Round 903 (Div. 3)
    使用 Docker + Jenkins + Gitlab + Maven 自动化部署 Spring Boot
    【杂项学习】Open3D的基本使用
    C Primer Plus(6) 中文版 第5章 运算符、表达式和语句 5.4 表达式和语句
    【源码系列#05】Vue3响应式原理（Ref）
    1小时拿下 Nginx - 3. Nginx 配置文件详解
  • 原文地址：https://blog.csdn.net/damadashen/article/details/126904544