• Pandas-02（描述性统计、函数的应用、重建索引、迭代）

    目录

    1.描述性统计

     1.1 常用描述性统计

     1.2 数据总结：describe()

     2. 函数的应用

     2.1  pipe()表级函数的应用

     2.2  apply()行列级函数应用

     2.3  agg();transform()聚合 API

     2.4 applymap()元素级函数应用

    3. 重建索引

    3.1 重建索引

    3.2 重置索引，填充空值

    3.3  重置索引，并与其它对象对齐

    3.4 重命名索引

    4.迭代

    4.1 基础迭代for in循环

    4.2 字典式item()迭代

    1.描述性统计

    Series与 DataFrame支持大量计算描述性统计的方法与操作。这些方法大部分都是 sum()、mean()、quantile()等聚合函数，其输出结果比原始数据集小；此外，还有输出结果与原始数据集同样大小的 cumsum()、 cumprod()等函数。这些方法都基本上都接受 axis 参数，如， ndarray.{sum,std,…}，但这里的 axis 可以用名称或整数指定：

    • Series：无需 axis 参数
    • DataFrame：
      • index，即 axis=0，默认值
      • columns, 即 axis=1

     1.1 常用描述性统计

    函数描述
    count统计非空值数量
    sum汇总值
    mean平均值
    mad平均绝对偏差
    median算数中位数
    min最小值
    max最大值
    mode众数
    abs绝对值
    prod乘积
    std贝塞尔校正的样本标准偏差
    var无偏方差
    sem平均值的标准误差
    skew样本偏度 (第三阶)
    kurt样本峰度 (第四阶)
    quantile样本分位数 (不同 % 的值)
    cumsum累加
    cumprod累乘
    cummax累积最大值
    cummin累积最小值

    示例如下：

    1. import pandas as pd
    2. import numpy as np
    3.  
    4. d = {
    5.     "name":pd.Series(['小明','小黑','小红']),
    6.     'age':pd.Series([12,16,14]),
    7.     'score':pd.Series([98,90,77])
    8. }
    9.  
    10. df = pd.DataFrame(d)
    11.  
    12. #sum求和函数,按照轴进行求和，默认是按照列轴，axis = 0
    13. df.sum()
    14.  
    15. #设置按行求和，axis =1
    16. df.sum(1)
    17.  
    18. # 求平均
    19. df.mean()
    20.  
    21. # 求标准差
    22. df.std()
    23.  
    24. # 求列最小值
    25. df.min()
    26.  
    27. # 求列最大值
    28. df.max()
    29.  
    30. # 求age和score列的绝对值
    31. df[['age','score']].abs()

    输出结果：

    1.     name   age	score
    2. 0	小明	12	98
    3. 1	小黑	16	90
    4. 2	小红	14	77
    5.  
    6. #sum求和函数,按照轴进行求和，默认是按照列轴，axis = 0
    7. name     小明小黑小红
    8. age          42
    9. score       265
    10. dtype: object
    11.  
    12. #设置按行求和，axis =1
    13. 0    110
    14. 1    106
    15. 2     91
    16. dtype: int64
    17.  
    18. # 求平均
    19. age      14.000000
    20. score    88.333333
    21. dtype: float64
    22.  
    23. # 求标准差
    24. age       2.000000
    25. score    10.598742
    26. dtype: float64
    27.  
    28. # 求最小值
    29. name     小明
    30. age      12
    31. score    77
    32. dtype: object
    33.  
    34. # 求最大值
    35. name     小黑
    36. age      16
    37. score    98
    38. dtype: object
    39.  
    40. # 求age和score列的绝对值
    41.    age	score
    42. 0	12	98
    43. 1	16	90
    44. 2	14	77

     1.2 数据总结：describe()

    describe()函数计算Series 与 DataFrame 数据列的各种数据统计量，注意，这里排除了空值。

    示例：接上述案例实例化的dataframe对象

    1. # 数据描述
    2. df.describe()
    3.  
    4. # 使用include/exclude指定或排除描述的参数类型，如object，number，all等类型
    5. df.describe(include="object")
    6. df.describe(include="number")
    7. df.describe(include="all")

    输出结果：

    df.describe()

    df.describe(include="object") 

     

     df.describe(include="number")

     df.describe(include="all")

     2. 函数的应用

    不管是为 Pandas 对象应用自定义函数，还是应用第三方函数，都离不开以下三种方法。用哪种方法取决于操作的对象是 DataFrame，还是 Series ；是行、列，还是元素。

    1. 表级函数应用：pipe()

    2. 行列级函数应用： apply()

    3. 聚合 API： agg()与 transform()

    4. 元素级函数应用：applymap()

    2.1  pipe()表级函数的应用

    在pipe(fn，args)函数中，会将dataframe作为函数fn传入的第一个参数，args等后续参数作为函数传入的后续参数。例如下面案例中，将以df内的数据为add（）传入的ele1，将2作为ele2。

    示例：

    1. # 需要将df中所有元素的内容加2
    2. import pandas as pd
    3. import numpy as np
    4.  
    5. def add(ele1,ele2):
    6.     return ele1+ele2
    7.  
    8. df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
    9. print(df)
    10.  
    11.  
    12. # pipe()
    13. df.pipe(add,2)
    14. print(df)

    实现效果：

    原始df：

     调用add函数后的df：

     2.2  apply()行列级函数应用

    apply()方法沿着 DataFrame 的轴应用函数，比如，描述性统计方法，该方法支持 axis 参数。

    默认情况下，apply()方法调用的函数返回的类型会影响 DataFrame.apply 输出结果的类型。

    • 函数返回的是 Series 时，最终输出结果是 DataFrame。输出的列与函数返回的 Series 索引相匹配。

    • 函数返回其它任意类型时，输出结果是 Series。

    基本语法：

    apply(fn,axis)

    例如计算沿水平方向的标准差：

    df.apply(np.std,axis=1) #根据水平计算

    输出结果：

     2.3  agg();transform()聚合 API

    agg()与transform()函数的用法基本相同，但transform()方法返回的结果与原始数据索引相同，大小相同。下面以agg()方法为例进行使用。

    1.  单聚合模式

    agg()应用单个函数时，该操作与apply()等效，这里也可以用字符串表示聚合函数名。例如：

    1. df.apply(np.std) 
    2. ==
    3. df.agg(np.std)

    2. 多聚和模式

    还可以用列表形式传递多个聚合函数。每个函数在输出结果 DataFrame 里以行的形式显示，行名是每个聚合函数的函数名。

    例如聚合上述dataframe中每一列的总和及标准差：

    df.agg(['sum',np.std])

    输出结果：

    或使用字典实现聚合：

    df.agg({'col1': 'mean', 'col2': 'sum','col3':'std'})

     

     2.4 applymap()元素级函数应用

     并非所有函数都能矢量化，即接受 NumPy 数组，返回另一个数组或值，DataFrame 的 applymap()及 Series 的 map()，支持任何接收单个值并返回单个值的 Python 函数。

    例如使用applymap()对每一个元素进行乘以100的操作：

    1. #applymap每一个元素进行操作
    2. df.applymap(lambda x:x*100)

    实现效果：

    3. 重建索引

    reindex()是 Pandas 里实现数据对齐的基本方法，该方法执行几乎所有功能都要用到的标签对齐功能。 reindex 指的是沿着指定轴，让数据与给定的一组标签进行匹配。该功能完成以下几项操作：

    • 让现有数据匹配一组新标签，并重新排序；
    • 在无数据但有标签的位置插入缺失值（NA）标记；
    • 如果指定，则按逻辑填充无标签的数据，该操作多见于时间序列数据。

     示例：

    3.1 重建索引

    reindex（index，columns，axis）其中：

    index为索引值（行）；

    columns为列值；

    axis为轴，值为index或columns。

    1. import pandas as pd
    2. import numpy as np
    3. df = pd.DataFrame({
    4.     "a":pd.date_range(start='2020-01-01',periods=5,freq="D"),
    5.     'b':[1,2,3,4,5],
    6.     'c':[0.1,0.2,0.3,0.4,0.5]
    7. })
    8. df
    9.  
    10. #重建索引reIndex
    11. df.reindex(index=[0,2,4],columns=['a','b','d'])
    12. df

     初始dataframe：

     

    重建索引后dataframe：

     

     3.2 重置索引，填充空值

    方法动作
    pad / ffill先前填充
    bfill / backfill向后填充
    nearest从最近的索引值填充
    1. #向前填充
    2. df.reindex(index=[0,5,6],columns=['a','b','c'],method="ffill")

     

    3.3  重置索引，并与其它对象对齐

    提取一个对象，并用另一个具有相同标签的对象 reindex 该对象的轴。这种操作的语法虽然简单，但未免有些啰嗦。这时，最好用reindex_like()方法，这是一种既有效，又简单的方式：

    1. df1 = pd.DataFrame({
    2.     "g":pd.date_range(start='2020-01-01',periods=5,freq="D"),
    3.     'b':[1,2,3,4,5],
    4.     'c':[0.1,0.2,0.3,0.4,0.5]
    5. })
    6. #填充加注
    7. df.reindex_like(df1)

     

    3.4 重命名索引

    rename()方法支持按不同的轴基于映射（字典或 Series）调整标签。

    基本语法：

    df.rename(columns={'one': 'foo', 'two': 'bar'},index={'a': 'apple', 'b': 'banana'})

    示例：

    1. #重命名
    2. df1.rename(columns={'g':"ggg",'b':'hello','c':"tom"})

     输出结果：

    4.迭代

    Pandas 对象基于类型进行迭代操作。Series 迭代时被视为数组，基础迭代生成值。DataFrame 则遵循字典式习语，用对象的 key 实现迭代操作。

    4.1 基础迭代for in循环

    基础迭代（for i in object）生成：

    • Series ：值
    • DataFrame：列标签

     示例：

    1. import pandas as pd
    2. import numpy as np
    3.  
    4. df = pd.DataFrame({
    5.     'date':pd.date_range(start='2020-01-01',periods=7,freq="D"),
    6.     'a':np.linspace(0,6,7),
    7.     'b':np.random.rand(7),
    8.     'c':np.random.choice(['Low','Medium','High'],7).tolist(),
    9.     'd':np.random.normal(100,10,size=(7)).tolist()
    10. })
    11.  
    12. df

    输出结果：

     使用基础迭代（for i in object）循环列数据：

    1. #for in 循环，循环的是列
    2. for col in df:
    3.     print(col)
    4.     print("-----------")
    5.     print(df[col])

     输出结果：

    1. date
    2. -----------
    3. 0   2020-01-01
    4. 1   2020-01-02
    5. 2   2020-01-03
    6. 3   2020-01-04
    7. 4   2020-01-05
    8. 5   2020-01-06
    9. 6   2020-01-07
    10. Name: date, dtype: datetime64[ns]
    11. a
    12. -----------
    13. 0    0.0
    14. 1    1.0
    15. 2    2.0
    16. 3    3.0
    17. 4    4.0
    18. 5    5.0
    19. 6    6.0
    20. Name: a, dtype: float64
    21. b
    22. -----------
    23. 0    0.528330
    24. 1    0.690732
    25. 2    0.505649
    26. 3    0.572986
    27. 4    0.543452
    28. 5    0.092484
    29. 6    0.665942
    30. Name: b, dtype: float64
    31. c
    32. -----------
    33. 0      High
    34. 1    Medium
    35. 2    Medium
    36. 3    Medium
    37. 4      High
    38. 5      High
    39. 6      High
    40. Name: c, dtype: object
    41. d
    42. -----------
    43. 0     94.385040
    44. 1     87.748938
    45. 2    114.945423
    46. 3    107.408004
    47. 4     91.328902
    48. 5    105.160663
    49. 6     92.128187
    50. Name: d, dtype: float64

    4.2 字典式item()迭代

    用下列方法可以迭代 DataFrame 里的行：

    • iterrows()：把 DataFrame 里的行当作 （index， Series）对进行迭代。该操作把行转为 Series，同时改变数据类型，并对性能有影响。

    • itertuples()把 DataFrame 的行当作值的命名元组进行迭代。该操作比 iterrows()快的多，建议尽量用这种方法迭代 DataFrame 的值。

    4.2.1 iteritem（）

    示例：

    1. #iteritem
    2. for key,value in df.iteritems():
    3.     print(key)
    4.     print(value)
    5.     print("----------")

    输出结果：

    1. date
    2. 0   2020-01-01
    3. 1   2020-01-02
    4. 2   2020-01-03
    5. 3   2020-01-04
    6. 4   2020-01-05
    7. 5   2020-01-06
    8. 6   2020-01-07
    9. Name: date, dtype: datetime64[ns]
    10. ----------
    11. a
    12. 0    0.0
    13. 1    1.0
    14. 2    2.0
    15. 3    3.0
    16. 4    4.0
    17. 5    5.0
    18. 6    6.0
    19. Name: a, dtype: float64
    20. ----------
    21. b
    22. 0    0.528330
    23. 1    0.690732
    24. 2    0.505649
    25. 3    0.572986
    26. 4    0.543452
    27. 5    0.092484
    28. 6    0.665942
    29. Name: b, dtype: float64
    30. ----------
    31. c
    32. 0      High
    33. 1    Medium
    34. 2    Medium
    35. 3    Medium
    36. 4      High
    37. 5      High
    38. 6      High
    39. Name: c, dtype: object
    40. ----------
    41. d
    42. 0     94.385040
    43. 1     87.748938
    44. 2    114.945423
    45. 3    107.408004
    46. 4     91.328902
    47. 5    105.160663
    48. 6     92.128187
    49. Name: d, dtype: float64
    50. ----------

    4.2.2 iterrows()

    1. # 取行值
    2. for key,value in df.iterrows():
    3.     print(key)
    4.     print(value)

    输出结果：

    1. 0
    2. date    2020-01-01 00:00:00
    3. a                         0
    4. b                  0.325726
    5. c                       Low
    6. d                   79.9946
    7. Name: 0, dtype: object
    8. 1
    9. date    2020-01-02 00:00:00
    10. a                         1
    11. b                  0.507182
    12. c                       Low
    13. d                   92.1191
    14. Name: 1, dtype: object
    15. 2
    16. date    2020-01-03 00:00:00
    17. a                         2
    18. b                  0.219389
    19. c                    Medium
    20. d                   100.214
    21. Name: 2, dtype: object
    22. 3
    23. date    2020-01-04 00:00:00
    24. a                         3
    25. b                  0.466743
    26. c                      High
    27. d                   114.725
    28. Name: 3, dtype: object
    29. 4
    30. date    2020-01-05 00:00:00
    31. a                         4
    32. b                  0.268522
    33. c                    Medium
    34. d                   102.523
    35. Name: 4, dtype: object
    36. 5
    37. date    2020-01-06 00:00:00
    38. a                         5
    39. b                 0.0869462
    40. c                      High
    41. d                   91.1989
    42. Name: 5, dtype: object
    43. 6
    44. date    2020-01-07 00:00:00
    45. a                         6
    46. b                  0.599297
    47. c                       Low
    48. d                   112.741
    49. Name: 6, dtype: object

    4.2.3 itertuples()

    1. # 取行内容
    2. for row in df.itertuples():
    3.     print(row)

    输出结果：

     

  • 相关阅读:
    Unity界面介绍：其它视图
    软件设计师 下午题第6题
    容易被忽视的CNN模型的感受野及其计算
    LeetCode(力扣)70. 爬楼梯Python
    构造函数调用原则
    【python基础】python的继承与多态，子类中调用父类方法和属性
    【滤波跟踪】基于GMPHD实现多目标运动跟踪附matlab代码
    一些 dp 题
    Web开发 前端介绍 HTML CSS
    擎创技术流 | ClickHouse实用工具—ckman教程（1）部署安装
  • 原文地址：https://blog.csdn.net/damadashen/article/details/126897040