• Pandas-03（字符串与文本数据、索引和选择数据、统计函数、窗口函数）

    目录

    1.字符串与文本数据

    2. 索引和选择数据

    2.1 .loc()按标签进行选择

    2.2 .iloc()按位置进行选择

    2.3 使用属性获取数据

    3.  统计函数

    3.1 百分比变化.pct_change()

    3.2 协方差.cov()

    3.3 相关性.corr()

    3.4 数据排名.rank()

    4. 窗口函数

    1.字符串与文本数据

    Series 支持字符串处理方法，可以非常方便地操作数组里的每个元素。这些方法会自动排除缺失值与空值，这也许是其最重要的特性。这些方法通过 Series 的 str 属性访问，一般情况下，这些操作的名称与内置的字符串方法一致，例如.lower();.upper();.len()等基础方法。

    示例：

    1. import pandas as pd
    2. import numpy as np
    3.  
    4. s = pd.Series([' Tom ',' xiaoming ',' john '])
    5. s
    6.  
    7. #删除空格
    8. s.str.strip()
    9.  
    10. #字符串分割
    11. s.str.split('o')
    12.  
    13. #字符串拼接
    14. s.str.cat(sep="<=>")
    15.  
    16. #辨别分类
    17. s.str.get_dummies()
    18.  
    19. #字符串包含的内容
    20. s.str.contains('m')
    21.  
    22. #字符串替换
    23. s.str.replace('o',"dd")
    24.  
    25. #计数
    26. s.str.count('i')
    27.  
    28. #对一系列字符串判断是否是数字
    29. s = pd.Series([' Tom ','778899',' xiaoming ',' john '])
    30. s.str.isnumeric()

    输出结果：

    1. # 原始Series
    2. 0          Tom 
    3. 1     xiaoming 
    4. 2         john 
    5. dtype: object
    6.  
    7. # 删除空格
    8. 0         Tom
    9. 1    xiaoming
    10. 2        john
    11. dtype: object
    12.  
    13. # 字符串以o进行分割
    14. 0         [ T, m ]
    15. 1    [ xia, ming ]
    16. 2        [ j, hn ]
    17. dtype: object
    18.  
    19. # 字符串拼接
    20. ' Tom <=> xiaoming <=> john '
    21.  
    22. # 辨别分类
    23. 	Tom	john xiaoming
    24. 0	1	 0	   0
    25. 1	0	 0	   1
    26. 2	0	 1	   0
    27.  
    28. # 字符串包含的内容
    29. 0     True
    30. 1     True
    31. 2    False
    32. dtype: bool
    33.  
    34. # 字符串替换
    35. 0          Tddm 
    36. 1     xiaddming 
    37. 2         jddhn 
    38. dtype: object
    39.  
    40. # 计数（字符串中i的数量）
    41. 0    0
    42. 1    2
    43. 2    0
    44. dtype: int64
    45.  
    46. # 对一系列字符串判断是否是数字
    47. 0    False
    48. 1     True
    49. 2    False
    50. 3    False
    51. dtype: bool

    2. 索引和选择数据

    在pandas中，除了使用index下标或column列名索引外，还可以使用.loc();.iloc()进行数据索引。

    2.1 .loc()按标签进行选择

    pandas 提供了一套方法来实现纯粹的基于标签的索引。这是一个严格的基于包含的协议。要求的每个标签都必须在索引中，否则KeyError将被提出。切片时，如果索引中存在，则包括起始边界和停止边界。整数是有效的标签，但它们指的是标签而不是位置。

    该.loc属性是主要的访问方法。以下是有效输入：

    • 单个标签，例如5或'a'（请注意，它5被解释为索引的标签。此用法不是沿索引的整数位置。）。

    • 标签列表或数组。['a', 'b', 'c']

    • 带有标签的切片对象'a':'f'（请注意，与通常的 Python 切片相反，开始和停止都包含在索引中！请参阅带标签的切片。

    • 一个布尔数组。

    • A callable，请参阅按 Callable 选择。

    示例：随机生成一个八行撕裂的数据进行操作

    1. import pandas as pd
    2. import numpy as np
    3.  
    4.  
    5. df = pd.DataFrame(np.random.randn(8,4),index=['a','b','c','d','e','f','g','h'],columns=["A","B","C","D"])
    6. df
    7.  
    8. #  输出结果
    9. 	A	            B	        C	       D
    10. a	0.529671	-0.076485	0.379469	1.494926
    11. b	-0.082312	-0.328869	0.175183	-0.798430
    12. c	0.681922	0.741320	-0.910726	-2.176608
    13. d	1.500632	-1.165229	0.316722	0.402977
    14. e	-2.044217	0.930242	0.433050	0.542472
    15. f	1.332038	0.476599	1.661994	2.102483
    16. g	0.488362	-1.667154	-0.651079	-0.049332
    17. h	-0.676308	0.904894	1.592176	0.409881

    1. 选择AB列的所有内容（使用切片）

    1. #选择A.B列所有的内容，基于标签
    2. df.loc[:,['A','B']]
    3.  
    4. #输出结果
    5.         A	        B
    6. a	0.529671	-0.076485
    7. b	-0.082312	-0.328869
    8. c	0.681922	0.741320
    9. d	1.500632	-1.165229
    10. e	-2.044217	0.930242
    11. f	1.332038	0.476599
    12. g	0.488362	-1.667154
    13. h	-0.676308	0.904894

    2.  选择a-e行，b以后的列（切片）

    1. #选择a-e行，b以后的列
    2. df.loc['a':'e','B':]
    3.  
    4.  
    5. # 输出结果：
    6.         B	        C	        D
    7. a	-0.076485	0.379469	1.494926
    8. b	-0.328869	0.175183	-0.798430
    9. c	0.741320	-0.910726	-2.176608
    10. d	-1.165229	0.316722	0.402977
    11. e	0.930242	0.433050	0.542472

    3. 取出a标签中大于1的数据

    1. # 取出a标签里大于一的数据
    2. df.loc['a']>1
    3.  
    4. # 输出结果
    5. A    False
    6. B    False
    7. C    False
    8. D     True
    9. Name: a, dtype: bool

    4.  取出a大于1的那一列内容

    1. # 取出a大于1的那一列内容
    2. df.loc[:,df.loc['a']>1]
    3.  
    4.  
    5. #输出结果：
    6.         D
    7. a	1.494926
    8. b	-0.798430
    9. c	-2.176608
    10. d	0.402977
    11. e	0.542472
    12. f	2.102483
    13. g	-0.049332
    14. h	0.409881

    2.2 .iloc()按位置进行选择

    pandas 提供了一套方法来获得纯粹的基于整数的索引。语义紧跟 Python 和 NumPy 切片。这些是0-based索引。切片时，包括起始边界，排除上限。尝试使用非整数，即使是有效标签也会引发IndexError.

    该.iloc属性是主要的访问方法。以下是有效输入：

    • 一个整数，例如5。

    • 整数列表或数组。[4, 3, 0]

    • 带有 ints 的切片对象1:7。

    • 一个布尔数组。

    • A callable，请参阅按 Callable 选择。

    示例：继上述案例的dataframe

    1.         A	        B	       C	       D
    2. a	0.529671	-0.076485	0.379469	1.494926
    3. b	-0.082312	-0.328869	0.175183	-0.798430
    4. c	0.681922	0.741320	-0.910726	-2.176608
    5. d	1.500632	-1.165229	0.316722	0.402977
    6. e	-2.044217	0.930242	0.433050	0.542472
    7. f	1.332038	0.476599	1.661994	2.102483
    8. g	0.488362	-1.667154	-0.651079	-0.049332
    9. h	-0.676308	0.904894	1.592176	0.409881

    1.  基于（行）位置的索引

    1. # 基于（行）位置的索引
    2. df.iloc[0]
    3.  
    4.  
    5. #输出结果：
    6. A    0.529671
    7. B   -0.076485
    8. C    0.379469
    9. D    1.494926
    10. Name: a, dtype: float64
    11.  
    12.  
    13. df.iloc[1]
    14.  
    15. #输出结果：
    16. A   -0.082312
    17. B   -0.328869
    18. C    0.175183
    19. D   -0.798430
    20. Name: b, dtype: float64

    2. 取出第三行第二列以后的内容

    1. df.iloc[3:,1:]
    2.  
    3.  
    4. #输出结果：
    5.         B	        C	       D
    6. d	-1.165229	0.316722	0.402977
    7. e	0.930242	0.433050	0.542472
    8. f	0.476599	1.661994	2.102483
    9. g	-1.667154	-0.651079	-0.049332
    10. h	0.904894	1.592176	0.409881

    2.3 使用属性获取数据

    对于上述数据，在pandas中，也可以采用属性获取方式取出数据。

    示例：取出A列和D列的数据

    1. #属性获取，取出A列内容
    2. df.A
    3.  
    4. #输出结果：
    5. a    1.310455
    6. b   -1.015628
    7. c    1.281924
    8. d    0.496812
    9. e   -1.733183
    10. f    0.140338
    11. g   -0.179063
    12. h   -0.642013
    13. Name: A, dtype: float64
    14.  
    15.  
    16.  
    17. df.D
    18.  
    19. #输出结果：
    20. a   -0.298131
    21. b   -1.141310
    22. c   -0.302760
    23. d    1.188531
    24. e   -1.608952
    25. f    0.437460
    26. g   -0.696010
    27. h   -0.525048
    28. Name: D, dtype: float64

    3.  统计函数

    pandas中提供多种统计函数供用户使用，如百分比变化.pct_change();协方差.cov();相关性.corr();数据排名.rank()方法

    3.1 百分比变化.pct_change()

    Series并DataFrame有一种方法.pct_change()来计算给定周期数内的百分比变化（在计算百分比变化之前fill_method使用填充 NA/null 值）。

    基本语法：

    1. Series.pct_change()
    2. or
    3. DataFrame.pct_change(periods=行数)

    示例：

    1. import pandas as pd
    2. import numpy as np
    3.  
    4. #创建基础Series
    5. s = pd.Series([877,865,874,890,912])
    6. s
    7.  
    8. # 输出结果：
    9. 0    877
    10. 1    865
    11. 2    874
    12. 3    890
    13. 4    912
    14. dtype: int64
    15.  
    16.  
    17. #创建基础dataframe
    18. df = pd.DataFrame(np.random.randn(5, 4))
    19. df
    20.  
    21. #输出结果
    22.         0	         1	        2	       3
    23. 0	0.655875	-2.195588	-0.785019	1.122582
    24. 1	0.852057	-2.276063	1.528201	-0.167119
    25. 2	-1.057979	-0.396548	-0.915528	0.026226
    26. 3	-0.490155	1.803235	0.005851	-1.252117
    27. 4	0.946558	-2.680471	-0.055739	-0.624553

    获取变化的百分比：

    1. # 变化的百分比程度（波动变化）
    2. s.pct_change()
    3.  
    4.  
    5. #输出结果：
    6. 0         NaN
    7. 1   -0.013683
    8. 2    0.010405
    9. 3    0.018307
    10. 4    0.024719
    11. dtype: float64
    12.  
    13.  
    14.  
    15. # 变化的百分比程度
    16. df.pct_change(periods=1)
    17.  
    18.  
    19. # 输出结果：
    20.  
    21.         0	        1	         2	         3
    22. 0	     NaN	     NaN	     NaN	     NaN
    23. 1	0.299115	0.036653	-2.946706	-1.148870
    24. 2	-2.241677	-0.825775	-1.599088	-1.156933
    25. 3	-0.536707	-5.547331	-1.006391	-48.742482
    26. 4	-2.931143	-2.486479	-10.526903	-0.501202

    3.2 协方差.cov()

    Series.cov()可用于计算系列之间的协方差（不包括缺失值）。

    DataFrame.cov()计算DataFrame 中系列之间的成对协方差，也排除 NA/null 值。

    示例：

    1. #计算两个Series之间的协方差
    2. s1 = pd.Series(np.random.randn(10))
    3. s2 = pd.Series(np.random.randn(10))
    4.  
    5.  
    6. #两个数据的协方差
    7. s1.cov(s2)
    8.  
    9.  
    10. #输出结果：
    11. -0.0751790891671201
    12.  
    13.  
    14.  
    15. # 计算dataframe中数据的协方差
    16. frame = pd.DataFrame(np.random.randn(1000, 5), columns=["a", "b", "c", "d", "e"])
    17.  
    18.  
    19. frame.cov()
    20.  
    21. #输出结果：
    22.        a         b         c         d         e
    23. a  1.000882 -0.003177 -0.002698 -0.006889  0.031912
    24. b -0.003177  1.024721  0.000191  0.009212  0.000857
    25. c -0.002698  0.000191  0.950735 -0.031743 -0.005087
    26. d -0.006889  0.009212 -0.031743  1.002983 -0.047952
    27. e  0.031912  0.000857 -0.005087 -0.047952  1.042487

     DataFrame.cov还支持一个可选min_periods关键字，该关键字指定每个列对所需的最小观察次数，以便获得有效结果。例如

    frame.cov(min_periods=12)

    观察dataframe中最少12列数据，若不够12列则返回NaN。

    3.3 相关性.corr()

    可以使用该.coor()方法计算相关性。使用该method参数，提供了几种计算相关性的方法：

    方法名称

    描述

    pearson (default)

    标准相关系数

    kendall

    Kendall Tau 相关系数

    spearman

    Spearman等级相关系数

    示例：

    1. 两个series之间的相关性

    1. s1 = pd.Series(np.random.randn(10))
    2. s2 = s1*2
    3.  
    4. #相关性（s1与s2）
    5. s1.corr(s2)
    6.  
    7. #输出结果：
    8. 0.9999999999999999

     2. 三组数据之间的相关性（dataframe）

    1. s1 = pd.Series(np.random.randn(10))
    2. s2 = s1*2
    3. s3 = pd.Series(np.random.randn(10))
    4. df = pd.DataFrame({
    5.     's1':s1,
    6.     's2':s2,
    7.     's3':s3
    8. })
    9.  
    10. df
    11. # 输出dataframe
    12.         s1	        s2	       s3
    13. 0	-1.149359	-2.298718	0.742016
    14. 1	0.476084	0.952168	-0.375759
    15. 2	-0.998627	-1.997255	0.721653
    16. 3	1.047331	2.094663	-0.078039
    17. 4	0.444710	0.889420	-0.525895
    18. 5	-0.411778	-0.823557	-0.402789
    19. 6	-0.935911	-1.871822	-0.597614
    20. 7	-0.652570	-1.305140	0.636498
    21. 8	1.055361	2.110722	-0.763907
    22. 9	-1.222631	-2.445262	-0.153914
    23.  
    24.  
    25. # 三者相关性
    26. df.corr()
    27.  
    28. #输出结果：
    29.         s1	       s2	       s3
    30. s1	1.000000	1.000000	-0.548589
    31. s2	1.000000	1.000000	-0.548589
    32. s3	-0.548589	-0.548589	1.000000

    3.4 数据排名.rank()

    .rank()方法生成一个数据排名，其中关系被分配了组的排名平均值,例如：

    1. s = pd.Series([877,865,874,890,912])
    2. s
    3.  
    4. #输出结果：
    5. 0    877
    6. 1    865
    7. 2    874
    8. 3    890
    9. 4    912
    10. dtype: int64
    11.  
    12.  
    13.  
    14. s.rank()
    15. #输出结果：
    16. 0    3.0
    17. 1    1.0
    18. 2    2.0
    19. 3    4.0
    20. 4    5.0
    21. dtype: float64

    在dataframe中，rank()可以对行 ( axis=0) 或列 ( axis=1) 进行排名。NaN值被排除在排名之外。

    rank可选地采用ascending默认为 true 的参数；如果为 false，则对数据进行反向排名，较大的值分配较小的排名。

    rank支持不同的平局方法，由method 参数指定：

    • average: 并列组的平均排名

    • min: 组中排名最低的

    • max: 组内最高排名

    • first：按照它们在数组中出现的顺序分配的排名

    4. 窗口函数

    pandas 包含一组紧凑的 API，用于执行窗口操作 - 一种在值的滑动分区上执行聚合的操作。API 的功能与 API 类似groupby，Series并DataFrame使用必要的参数调用窗口化方法，然后调用聚合函数。

    pandas 支持 4 种类型的窗口操作：

    1. 滚动窗口：值上的通用固定或可变滑动窗口。

    2. 加权窗口：库提供的加权非矩形窗口scipy.signal。

    3. 扩展窗口：累积值的窗口。

    4. 指数加权窗口：值的累积和指数加权窗口。

    概念

    方法

    返回的对象

    支持基于时间的窗口

    支持链式groupby

    支持表格法

    支持在线操作

    卷帘窗

    rolling

    Rolling

    是的

    是的

    是>1.3

    不

    加权窗口

    rolling

    Window

    不

    不

    不

    不

    扩大窗口

    expanding

    Expanding

    不

    是的

    是>1.3

    不

    指数加权窗口

    ewm

    ExponentialMovingWindow

    不

    是>1.2

    不

    是（从 1.3 版开始）

     示例：

    1. import pandas as pd
    2. import numpy as np
    3.  
    4. df = pd.DataFrame(np.random.randn(10,4))
    5. df
    6. #输出结果：
    7.         0	        1	         2	       3
    8. 0	2.599818	0.451315	-0.428038	0.035233
    9. 1	0.395523	-0.098377	0.059649	-0.489922
    10. 2	0.550164	-0.469461	1.193710	0.567562
    11. 3	1.483434	-0.793989	-0.738174	0.515078
    12. 4	0.395409	0.425578	-0.439963	-0.207277
    13. 5	-0.035479	-1.438315	-0.863333	-0.129948
    14. 6	-0.336889	-0.094188	-1.452638	0.083352
    15. 7	-0.626117	0.120990	-0.566740	0.665003
    16. 8	-1.437816	-0.112235	-0.232150	-0.099910
    17. 9	-0.582537	0.388641	1.008226	0.321893

    1. .rolling() 卷帘窗

    1. # 滚动窗口求每三行之间的平均值
    2. df.rolling(window=3).mean()
    3.  
    4. #输出结果：
    5.  
    6.         0	        1	        2	      3
    7. 0	    NaN	       NaN	       NaN	      NaN
    8. 1	    NaN	       NaN	       NaN	      NaN
    9. 2	1.181835	-0.038841	0.275107	0.037625
    10. 3	0.809707	-0.453942	0.171729	0.197573
    11. 4	0.809669	-0.279291	0.005191	0.291788
    12. 5	0.614455	-0.602242	-0.680490	0.059284
    13. 6	0.007681	-0.368975	-0.918644	-0.084624
    14. 7	-0.332828	-0.470504	-0.960904	0.206135
    15. 8	-0.800274	-0.028478	-0.750509	0.216148
    16. 9	-0.882157	0.132465	0.069779	0.295662

     2. .expanding扩大窗口

    1. #expanding
    2. df.expanding(min_periods=3).mean()
    3.  
    4. #输出结果：
    5.         0	         1	        2	      3
    6. 0	     NaN	     NaN	     NaN	     NaN
    7. 1	     NaN	     NaN	     NaN	     NaN
    8. 2	1.181835	-0.038841	0.275107	0.037625
    9. 3	1.257235	-0.227628	0.021787	0.156988
    10. 4	1.084869	-0.096987	-0.070563	0.084135
    11. 5	0.898145	-0.320542	-0.202691	0.048455
    12. 6	0.721711	-0.288205	-0.381255	0.053440
    13. 7	0.553233	-0.237056	-0.404441	0.129885
    14. 8	0.332005	-0.223187	-0.385297	0.104352
    15. 9	0.240551	-0.162004	-0.245945	0.126106

  • 相关阅读:
    【名词解释】concolic testing和instrumentation
    实验1： 交换机MAC地址表学习过程实验
    双向控制舵机（树莓派版）
    编程的艺术：不嵌套主义
    链表、队列、栈、递归 复习刷题
    【JavaScript面试】map(）方法
    macos 不支持svn安装
    LIO-SAM运行报错[lio_sam_imuPreintegration-2]和[lio_sam_mapOptmization-5]解决
    【Web】标准文档流
    OpenCV学习（四）——轨迹栏（调色板与不同通道图像）
  • 原文地址：https://blog.csdn.net/damadashen/article/details/126901690