• Python学习笔记（十七）——Pandas库

    数组只能存储一种类型的数据， 同时， 数组提供了许多方便统计计算的功能 （如平均值 mean 、标准差 std 等）

    pandas与numpy的区别

    pandas 是基于 numpy 数组构的， 但 二者最大的不同是 pandas 是专门为处 理表格和混杂数据设计的，比较契合统 计分析中的表结构，而 numpy 更适合处 理统一的数值数组数据。
    举个例子进行对比 
    1. chengji=[['', '期末', '期末'], ['张三',50, 80], ['李四', 60, 90], ['王老五', 70, 89]]
    2. np.array(chengji)
    3.  
    4. #array([['', '期末', '期末'],
    5. #['张三', '50', '80'],
    6. #['李四', '60', '90'],
    7. #['王老五', '70', '89']], dtype='

    上图是使用numpy得出的结果

    1. dic={ ' 期 中 ':[50,60,70], ' 期 末':[80,90,89]}
    2. pd.DataFrame(dic,index=['张三','李四','王老五'])

    上图是使用pandas得出的结果

    Pandas库简介

    pandas官网

     pandas扩展包的安装

    1. win+R打开命令行
    2. 输入pip install pandas

    pandas扩展包的调用

    import pandas as pd

    pandas数据结构

     pandas库的理解

    NumpyPandas
    基础数据类型
    扩展数据类型
    关注数据的结构表达
    关注数据的应用表达
    维度：数据间的关系
    数据与索引间的关系

    相同操作，输出形式对比：

    1. np.arange(4)
    2.  
    3. #array([0,1,2,3])

    1. pd.Series(np.arange(4))
    2. #0 0
    3. #1 1
    4. #2 2
    5. #3 3
    6. #dtype: int32

    可以看出使用pandas库可视化程度更高，能以比较清晰直观的形式展现处理后的数据

    series对象类型

    Series 是一种类似于一维数组的对象，它由一组数据以及一组与之相关的索引组成，仅由一组数据即可产生最简单的Series

     series对象的创建

     dp.Serise(obj=None, index=None, dtype=None)

    对象的类型
    • 标量或 Python 列表
    • Python 字典
    • Ndarray
    • 其他函数
    index
    • 自动生成
    • 人为指定
    并存，但不能混用

     创建时注意事项

    标量值， index 表达 Series 类型的尺寸
    Python 列表， index 与列表元素个数一致
    Python 字典，键值对中的“键”是索引， index 从字典中进行选择操作
    ndarray ，索引和数据都可以通过 ndarray 类型创建
    其他函数， range() 函数等 

    1. b=pd.Series([9,8,7],['a','b','c'])
    2. #b
    3. #a 9
    4. #b 8
    5. #c 7
    6. #dtype: int64
    1. >>> b.values
    2. array([9, 8, 7], dtype=int64)
    3. >>>b.index #索引
    4. Index(['a', 'b', 'c'], dtype='object’)
    1. >>> b.index.name='索引' #定义索引的名字
    2. >>> b.name='Series对象' #对象名
    3. >>> b
    4. 索引
    5. a 9
    6. b 8
    7. c 7
    8. Name: Series对象, dtype: int64
    Series 类型的索引操作类似 ndarray 类型：
    • 索引方法相同，采用 []
    • NumPy 中运算和操作可用于 Series 类型
    • 可以通过自定义索引的列表进行切片
    • 可通过自动索引进行切片，如果存在自定义索引，则一同被切片 

    1. >>> b=pd.Series([9,8,7],['a','b','c'])
    2. >>> b
    3. a 9
    4. b 8
    5. c 7
    6. dtype: int64
    7.  
    8. >>> b[b>=b.median()]
    9. a 9
    10. b 8
    11. dtype: int64
    12.  
    13. >>> np.exp(b)
    14. a 8103.083928
    15. b 2980.957987
    16. c 1096.633158
    17. d 403.428793
    18. dtype: float64
    Series 类型的操作类似 Python 字典类型：
    • 通过自定义索引访问
    • 保留字 in 操作：判定给定的索引值是否在索引序列中
    • 使用 .get() 方法：类似于字典中的 get 方法 
    1. >>> b=pd.Series([9,8,7],['a','b','c'])
    2. >>> b
    3. a 9
    4. b 8
    5. c 7
    6. dtype: int64
    7.  
    8. >>> b['a']
    9. 9
    10. >>> 'c' in b
    11. True
    12.  
    13. >>> b.get('a')
    14. 9

    series常用函数 

    DataFrame对象类型

    1. DataFrame类型由共用相同索引的一组列组成。
    2. DataFrame是一个表格型的数据类型，每列值类型可以不同
    3. DataFrame既有行索引(index)、也有列索引(columns)
    4. DataFrame常用于表达二维数据，但可以表达多维数据。

     DataFrame创建

    pd.DataFrame(data=None, index=None, columns=None, dtype=None)
    主要待创建 obj 类型：
    • 二维 ndarray 对象
    • 由一维 ndarray 、列表、字典、元组或 Series 构成的字典
    • Series 类型
    • 其他的 DataFrame 类型
    columns，index 分别为指定行和列的索引值，列表类型。 

    1. df=pd.DataFrame(np.random.randint(60,100,size=(2,3)),index=['期中','期末'],columns=['张三','李四','王老五'])
    2.  
    3. >>> df.values
    4. array([[70, 92, 72],
    5. [60, 60, 88]])
    6. >>> df.shape
    7. (2,3)
    8.  
    9. >>> df.index
    10. Index(['期中', '期末'], dtype='object')
    11. >>> df.columns
    12. Index(['张三', '李四', '王老五'], dtype='object')
    13.  
    14. >>> df.describe()
    15. 张三 李四 王老五
    16. count 2.000000 2.000000 2.000000
    17. mean 65.000000 76.000000 80.000000
    18. std 7.071068 22.627417 11.313708
    19. min 60.000000 60.000000 72.000000
    20. 25% 62.500000 68.000000 76.000000
    21. 50% 65.000000 76.000000 80.000000
    22. 75% 67.500000 84.000000 84.000000
    23. max 70.000000 92.000000 88.000000

     根据行列参数索引。

    1. >>> df.['x']
    2. a 0
    3. b 3
    4. c 6
    5. Name: x, dtype: int32

    根据整数位置参数索引

    1. >>> df.iloc[1,:]
    2. x 3
    3. y 4
    4. z 5
    5. Name:b, dtype: int32

    某个轴上拥有多个索引级别

    1. >>> df.['x','z']
    2. a 0 2
    3. b 3 5
    4. c 6 8

    列索引

    通过类似字典的方式：
    某一列 : obj[ 列索引值 ] 
    1. >>> df['qizhong']
    2. 张三 50
    3. 李四 60
    4. 王老五 70
    5. Name: qizhong, dtype: int64
    多列 : obj[ 列索引值列表 ] 
    1. >>> df[['qizhong', 'qimo']]
    2. qizhong qimo
    3. 张三 50 80
    4. 李四 60 90
    5. 王老五 70 89

    行索引

    使用 .loc[] 加 index 来进行行索引
    某一行 : obj.loc[ 行索引值 ] 
    1. >>> df.loc['张三']
    2. qizhong 50
    3. qimo 80
    4. Name: 张三, dtype: int64
    多行 : obj[ 行索引值列表 ] 
    1. >>> df.loc[['李四', '张三']]
    2. qizhong qimo
    3. 李四 60 90
    4. 张三 50 80

    效果图

    位置索引

    iloc 函数索引的数据是 int 整型， Python 默认的前闭后开。索引方式与数组类似

     

    连续索引与不连续索引 
    df=pd.DataFrame(np.arange(16).reshape((4,4)),index=["a","b","c","d"],columns=["w","x","y","z"])
    连续索引：索引值为切片 
    1. >>> df.loc['a':'c']
    2. >>> df.iloc[:3, :]
    3. w x y z
    4. a 0 1 2 3
    5. b 4 5 6 7
    6. c 8 9 10 11
    不连续索引：索引值为列表 
    1. >>> df[['w', 'y']]
    2. >>> df.iloc[:, [0,2]]
    3. w y
    4. a 0 2
    5. b 4 6
    6. c 8 10
    7. d 12 14

    重新索引

    .reindex() 能够改变或重排 Series 和 DataFrame 索引
    实例

    删除指定索引

    .drop() 能够删除 Series 和 DataFrame 指定行或列索引 
    pd.drop(labels, axis=0)
    1. >>> d
    2. 城市 环比 同比 定基
    3. 0 北京 101.5 120.7 121.4
    4. 1 上海 101.2 127.3 127.8
    5. 2 广州 101.3 119.4 120.0
    6. 3 深圳 102.0 145.5 125.3
    7. 4 沈阳 101.1 101.4 101.6
    1. >>> d.drop(3)
    2. 城市 环比 同比 定基
    3. 0 北京 101.5 120.7 121.4
    4. 1 上海 101.2 127.3 127.8
    5. 2 广州 101.3 119.4 120.0
    6. 4 沈阳 101.1 101.4 101.6
    7. >>> d.drop('同比', axis =1)
    8. 城市 环比 定基
    9. 0 北京 101.5 121.4
    10. 1 上海 101.2 127.8
    11. 2 广州 101.3 120.0
    12. 4 沈阳 101.1 101.6

    Pandas库常用操作

    算数运算法则
    • 算术运算根据行列索引，补齐后运算，运算默认产生浮点数；
    • 补齐时缺项填充 NaN ( 空值 ) ；
    • 采用 + ‐ * / 符号进行的二元运算产生新的对象；
    • 二维和一维、一维和零维间为广播运算；

    实例

    1. a=pd.DataFrame(np.arange(12).reshape((3,4))) 
    2. b=pd.DataFrame(np.arange(20).reshape((4,5)))
    运算结果为浮点型；
    hape大小不一致，缺失部分元素以NaN补全 
    1. >>> a
    2. 0 1 2 3
    3. 0 0 1 2 3
    4. 1 4 5 6 7
    5. 2 8 9 10 11
    6.  
    7. >>> b
    8. 0 1 2 3 4
    9. 0 0 1 2 3 4
    10. 1 5 6 7 8 9
    11. 2 10 11 12 13 14
    12. 3 15 16 17 18 19

     方法形式的运算

     实例

    1. >>> a
    2. 0 1 2 3
    3. 0 0 1 2 3
    4. 1 4 5 6 7
    5. 2 8 9 10 11
    6.  
    7. >>> b
    8. 0 1 2 3 4
    9. 0 0 1 2 3 4
    10. 1 5 6 7 8 9
    11. 2 10 11 12 13 14
    12. 3 15 16 17 18 19
    13.  
    14. #加法
    15. >>> b.add(a, fill_value=100)
    16. 0 1 2 3 4
    17. 0 0.0 2.0 4.0 6.0 104.0
    18. 1 9.0 11.0 13.0 15.0 109.0
    19. 2 18.0 20.0 22.0 24.0 114.0
    20. 3 115.0 116.0 117.0 118.0 119.0
    21.  
    22. #乘法
    23. >>> b.mul(b, fill_value=0)
    24. 0 1 2 3 4
    25. 0 0.0 1.0 4.0 9.0 0.0
    26. 1 20.0 30.0 42.0 56.0 0.0
    27. 2 80.0 99.0 120.0 143.0 0.0
    28. 3 0.0 0.0 0.0 0.0 0.0

    Series与Dataframe之间的计算

    使用 Python 操作符：
    • 以行为单位操作（参数必须是行），对所有行都有效。（类似于 numpy 中二维 数组与一维数
    组的运算，但可能出现 NaN ）
    使用 pandas 操作函数：
    • axis=0 ：以列为单位操作（参数必须是列），对所有列都有效。
    • axis=1 ：以行为单位操作（参数必须是行），对所有行都有效。

    传播运算（标量运算）

    不同维度数据类型之间的运算。
    标量与 Seriers 或 DataFrame 之间的运算（各元素均与标量运算） 
    1. >>> c=pd.Series(np.arange(3))
    2. 0 0
    3. 1 1
    4. 2 2
    5. dtype: int32
    6. >>> c+1
    7. 0 1
    8. 1 2
    9. 2 3
    10. dtype: int32
    11.  
    12. >>> a=pd.DataFrame(np.arange(12).reshape((3,4)))
    13. 0 1 2 3
    14. 0 0 1 2 3
    15. 1 4 5 6 7
    16. 2 8 9 10 11
    17. >>> a+1
    18. 0 1 2 3
    19. 0 1 2 3 4
    20. 1 5 6 7 8
    21. 2 9 10 11 12
    使用 Python 操作符：
    • 以行为单位操作（参数必须是行），对所有行都有效。（类似于 numpy 中二维数组与一维数
    组的运算，但可能出现 NaN ）
    使用 pandas 操作函数：
    • axis=0 ：以列为单位操作（参数必须是列），对所有列都有效。
    • axis=1 ：以行为单位操作（参数必须是行），对所有行都有效。
    传播运算（标量运算）
    不同维度数据类型之间的运算。
    标量与 Seriers 或 DataFrame 之间的运算（各元素均与标量运算） 
    1. >>> c=pd.Series(np.arange(3))
    2. 0 0
    3. 1 1
    4. 2 2
    5. dtype: int32
    6. >>> c+1
    7. 0 1
    8. 1 2
    9. 2 3
    10. dtype: int32
    11.  
    12. >>> a=pd.DataFrame(np.arange(12).reshape((3,4)))
    13. 0 1 2 3
    14. 0 0 1 2 3
    15. 1 4 5 6 7
    16. 2 8 9 10 11
    17. >>> a+1
    18. 0 1 2 3
    19. 0 1 2 3 4
    20. 1 5 6 7 8
    21. 2 9 10 11 12

    算数运算（传播机制）

    默认 Seriers 参与 DataFrame 的行运算
    将 Series 的索引匹配到 DataFrame的行，然后行一直向下传播。缺失元素 Nan 补全。 
    1. >>> c=pd.Series(np.arange(4))
    2. >>> a=pd.DataFrame(np.arange(12).reshape((3,4)))

    比较运算规则

    二维和一维、一维和零维间为广播运算
    采用 > < >= <= == != 等符号进行的二元运算产生布尔对象

    不同维度，广播运算，默认在 1 轴 ( 行 ) 
    1. >>> c=pd.Series(np.arange(4))
    2. >>> a=pd.DataFrame(np.arange(12).reshape((3,4)))

     

     

     索引的排序

    • .sort_index() 方法在指定轴上根据索引进行排序，默认在 0 轴升序。

     .sort_index(axis=0, ascending=True) 

    1. >>> b
    2. 0 1 2 3 4
    3. c 0 1 2 3 4
    4. a 5 6 7 8 9
    5. d 10 11 12 13 14
    6. b 15 16 17 18 19
    7.  
    8. >>> c=b.sort_index()
    9. 0 1 2 3 4
    10. a 5 6 7 8 9
    11. b 15 16 17 18 19
    12. c 0 1 2 3 4
    13. d 10 11 12 13 14
    14.  
    15. >>> c.sort_index(axis=1,ascending=False)
    16. 4 3 2 1 0
    17. a 9 8 7 6 5
    18. b 19 18 17 16 15
    19. c 4 3 2 1 0
    20. d 14 13 12 11 10
    .sort_values() 方法在指定轴上根据数值进行排序，默认升序

    DataFrame.sort_values(by=‘##’,axis=0,ascending=True, inplace=False) 

     

    1. a = [[9,3,1],[1,2,8],[1,0,5]]
    2. data = pd.DataFrame(a, index=["0", "2", "1"], columns=["c", "a", "b"])

    1. idx = pd.MultiIndex.from_tuples([('a', 1), ('a', 2), ('a', 2), ('b', 2), ('b', 1), ('b', 1)]) 
    2. idx.names = ['first', 'second']
    3. df_multi = pd.DataFrame({'A': np.arange(6, 0, -1)}, index=idx)

     

     汇总和计算描述统计

     汇总和计算描述统计：累计统计分析函数

    适用于 Series 和 DataFrame 类型，滚动计算（窗口计算） 

    obj = pd.Series(['c','a','d','a','a','b','b','c','c'])

     serieris.unique()：是以数组形式返回列的所有唯一值（特征的所有唯一值）

    1. >>> uniques = obj.unique()
    2. array(['c', 'a', 'd', 'b'], dtype=object)
    Series.nunique(): 返回的是唯一值的个数 
    1. >>> uniques = obj.nunique()
    2. 4
    serieris.value_counts() ：按 value 的出现次数多少
    降序排序 
    1. >>> obj.value_counts()
    2. a 3
    3. c 3
    4. b 2
    5. d 1
    6. dtype: int64
    pd.isin(values) ：来查看参数 values 是否在 Series/Data Frame 内，有返回按 DataFrame 分布布尔值 True ，否则 False 。
    values ： iterable, Series, DataFrame or dictt

    函数映射

    map 函数
    • 作用在 Series 的每个元素
    applymap 函数
    • 作用 DataFrame 所有元素
    apply 函数
    • 作用在 DataFrame 行或列
    df['col2'] = df['col1'].map(lambda x: x**2)
    对行列用函数处理
    apply 函数是 pandas 里面所有函数中自由度最高的函数
    DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds
    • func ： 函数，应用于每个列或行的函数；
    • axis ： =0 或 1 将函数应用于每一列或行；
    • raw ：默认将每个行或列作为系列传递给函数 , 否则传递的函数将改为接收 ndarray 对象；
    • result_type ： {‘expand’ ，‘ reduce’ ，‘ broadcast’ ， None} ，默认为 None 。仅在
    axis=1 情况下起作用，‘ expand’ ：类似列表的结果将变成列， 'reduce' ：如果可 能，
    返回一个 Series 。 ' broadcast ' ：结果将广播到 DataFrame 的原始形状 
    1. >>> name=["张三","李四 ","王五"]
    2. >>> idx=["指标1","指标2","指标3","指标4"]
    3. >>>df=pd.DataFrame(np.random.randint(67,80,12).reshape((3,4)),index=name,colum
    4. ns=idx)
    5. >>> df.apply(lambda x:((x-min(x))/(max(x)-min(x)),axis=1)
    1. 指标1 指标2 指标3 指标4
    2. 张三 70 70 72 77
    3. 李四 79 67 73 74
    4. 王五 67 74 69 724
    5.  
    6.     |
    7.     V
    8. 指标1 指标2 指标3 指标4
    9. 张三 0.0 0.0 0.285714 1.000000
    10. 李四 1.0 0.0 0.500000 0.583333
    11. 王五 0.0 1.0 0.285714 0.714286

    apply函数(对行列用函数处理)

     传送门：Python全套学习笔记

  • 相关阅读:
    【概念】数据仓库和数仓建模
    小满Vue3第三十六章（Vue如何开发移动端）
    我来泼盆冷水：正面迎击AI的时代千万别被ChatGPT割了韭菜
    一文带你学会Vue3基本语法
    flex布局（理论+案例解释）
    数字图像增强的一般方法
    从0开始的计组学习！让我们踏上计组的奇妙学习之旅叭~
    海外媒体发稿：8个提升影响力的日韩地区媒体发稿推广策略-华媒舍
    5(6)-羧基四甲基罗丹明，CAS号：150347-56-1
    Java 包
  • 原文地址：https://blog.csdn.net/weixin_60535956/article/details/127982314