devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Pandas中文官方文档：基础用法5

作者：菜鸟追梦旅行 | 2024-03-05 20:30:25

赞

踩

pandas官方文档中文


本文授权转载自Python大咖谈

禁止二次转载

大家好，我是老表

阅读文本大概需要 16 分钟

建议从头开始学习，本系列前四篇

  1. Pandas中文官方文档：基础用法1

  2. Pandas中文官方文档：基础用法2

  3. Pandas中文官方文档：基础用法3

  4. Pandas中文官方文档：基础用法4

.dt 访问器

Series 提供了一个可以简单、快捷返回 datetime 属性值的访问器。这个访问器返回的也是 Series，索引与现有的 Series 一样。

  1. # datetime
  2. In [264]: s = pd.Series(pd.date_range('20130101 09:10:12', periods=4))
  3.  
  4. In [265]: s
  5. Out[265]: 
  6. 0   2013-01-01 09:10:12
  7. 1   2013-01-02 09:10:12
  8. 2   2013-01-03 09:10:12
  9. 3   2013-01-04 09:10:12
  10. dtype: datetime64[ns]
  11.  
  12. In [266]: s.dt.hour
  13. Out[266]: 
  14. 0    9
  15. 1    9
  16. 2    9
  17. 3    9
  18. dtype: int64
  19.  
  20. In [267]: s.dt.second
  21. Out[267]: 
  22. 0    12
  23. 1    12
  24. 2    12
  25. 3    12
  26. dtype: int64
  27.  
  28. In [268]: s.dt.day
  29. Out[268]: 
  30. 0    1
  31. 1    2
  32. 2    3
  33. 3    4
  34. dtype: int64

用下列表达式进行筛选非常方便：

  1. In [269]: s[s.dt.day == 2]
  2. Out[269]: 
  3. 1   2013-01-02 09:10:12
  4. dtype: datetime64[ns]

还可以轻易实现时区转换：

  1. In [270]: stz = s.dt.tz_localize('US/Eastern')
  2.  
  3. In [271]: stz
  4. Out[271]: 
  5. 0   2013-01-01 09:10:12-05:00
  6. 1   2013-01-02 09:10:12-05:00
  7. 2   2013-01-03 09:10:12-05:00
  8. 3   2013-01-04 09:10:12-05:00
  9. dtype: datetime64[ns, US/Eastern]
  10.  
  11. In [272]: stz.dt.tz
  12. Out[272]: <DstTzInfo 'US/Eastern' LMT-1 day, 19:04:00 STD>

还可以把这些操作连在一起：

  1. In [273]: s.dt.tz_localize('UTC').dt.tz_convert('US/Eastern')
  2. Out[273]: 
  3. 0   2013-01-01 04:10:12-05:00
  4. 1   2013-01-02 04:10:12-05:00
  5. 2   2013-01-03 04:10:12-05:00
  6. 3   2013-01-04 04:10:12-05:00
  7. dtype: datetime64[ns, US/Eastern]

还可以用 Series.dt.strftime() 把 datetime 的值当成字符串进行格式化，支持与标准的 strftime() 同样的格式。

  1. # DatetimeIndex
  2. In [274]: s = pd.Series(pd.date_range('20130101', periods=4))
  3.  
  4. In [275]: s
  5. Out[275]: 
  6. 0   2013-01-01
  7. 1   2013-01-02
  8. 2   2013-01-03
  9. 3   2013-01-04
  10. dtype: datetime64[ns]
  11.  
  12. In [276]: s.dt.strftime('%Y/%m/%d')
  13. Out[276]: 
  14. 0    2013/01/01
  15. 1    2013/01/02
  16. 2    2013/01/03
  17. 3    2013/01/04
  18. dtype: object
  1. # PeriodIndex
  2. In [277]: s = pd.Series(pd.period_range('20130101', periods=4))
  3.  
  4. In [278]: s
  5. Out[278]: 
  6. 0    2013-01-01
  7. 1    2013-01-02
  8. 2    2013-01-03
  9. 3    2013-01-04
  10. dtype: period[D]
  11.  
  12. In [279]: s.dt.strftime('%Y/%m/%d')
  13. Out[279]: 
  14. 0    2013/01/01
  15. 1    2013/01/02
  16. 2    2013/01/03
  17. 3    2013/01/04
  18. dtype: object

.dt 访问器还支持 period 与 timedelta。

  1. # period
  2. In [280]: s = pd.Series(pd.period_range('20130101', periods=4, freq='D'))
  3.  
  4. In [281]: s
  5. Out[281]: 
  6. 0    2013-01-01
  7. 1    2013-01-02
  8. 2    2013-01-03
  9. 3    2013-01-04
  10. dtype: period[D]
  11.  
  12. In [282]: s.dt.year
  13. Out[282]: 
  14. 0    2013
  15. 1    2013
  16. 2    2013
  17. 3    2013
  18. dtype: int64
  19.  
  20. In [283]: s.dt.day
  21. Out[283]: 
  22. 0    1
  23. 1    2
  24. 2    3
  25. 3    4
  26. dtype: int64
  1. # timedelta
  2. In [284]: s = pd.Series(pd.timedelta_range('1 day 00:00:05', periods=4, freq='s'))
  3.  
  4. In [285]: s
  5. Out[285]: 
  6. 0   1 days 00:00:05
  7. 1   1 days 00:00:06
  8. 2   1 days 00:00:07
  9. 3   1 days 00:00:08
  10. dtype: timedelta64[ns]
  11.  
  12. In [286]: s.dt.days
  13. Out[286]: 
  14. 0    1
  15. 1    1
  16. 2    1
  17. 3    1
  18. dtype: int64
  19.  
  20. In [287]: s.dt.seconds
  21. Out[287]: 
  22. 0    5
  23. 1    6
  24. 2    7
  25. 3    8
  26. dtype: int64
  27.  
  28. In [288]: s.dt.components
  29. Out[288]: 
  30.    days  hours  minutes  seconds  milliseconds  microseconds  nanoseconds
  31. 0     1      0        0        5             0             0            0
  32. 1     1      0        0        6             0             0            0
  33. 2     1      0        0        7             0             0            0
  34. 3     1      0        0        8             0             0            0

::: tip 注意

用这个访问器处理不是 datetime 类型的值时，Series.dt 会触发 TypeError 错误。

:::

矢量化字符串方法

Series 支持字符串处理方法，操作数组中每个元素十分方便。这些方法会自动排除缺失值与空值，这也许是其最重要的特性。这些方法通过 Series 的 str 属性访问，一般情况下，这些操作的名称与内置的字符串方法一致。示例如下：

  1. In [289]: s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
  2.  
  3. In [290]: s.str.lower()
  4. Out[290]: 
  5. 0       a
  6. 1       b
  7. 2       c
  8. 3    aaba
  9. 4    baca
  10. 5     NaN
  11. 6    caba
  12. 7     dog
  13. 8     cat
  14. dtype: object

这里还提供了强大的模式匹配方法，但工业注意，模式匹配方法默认使用正则表达式。

参阅矢量化字符串方法了解完整内容。

排序

Pandas 支持三种排序方式，按索引标签排序，按列里的值排序，按两种方式混合排序。

按索引排序

Series.sort_index() 与 DataFrame.sort_index() 方法用于按索引层级对 pandas 对象排序。

  1. In [291]: df = pd.DataFrame({
  2.    .....:     'one': pd.Series(np.random.randn(3), index=['a', 'b', 'c']),
  3.    .....:     'two': pd.Series(np.random.randn(4), index=['a', 'b', 'c', 'd']),
  4.    .....:     'three': pd.Series(np.random.randn(3), index=['b', 'c', 'd'])})
  5.    .....: 
  6.  
  7. In [292]: unsorted_df = df.reindex(index=['a', 'd', 'c', 'b'],
  8.    .....:                          columns=['three', 'two', 'one'])
  9.    .....: 
  10.  
  11. In [293]: unsorted_df
  12. Out[293]: 
  13.       three       two       one
  14. a       NaN -1.152244  0.562973
  15. d -0.252916 -0.109597       NaN
  16. c  1.273388 -0.167123  0.640382
  17. b -0.098217  0.009797 -1.299504
  18.  
  19. # DataFrame
  20. In [294]: unsorted_df.sort_index()
  21. Out[294]: 
  22.       three       two       one
  23. a       NaN -1.152244  0.562973
  24. b -0.098217  0.009797 -1.299504
  25. c  1.273388 -0.167123  0.640382
  26. d -0.252916 -0.109597       NaN
  27.  
  28. In [295]: unsorted_df.sort_index(ascending=False)
  29. Out[295]: 
  30.       three       two       one
  31. d -0.252916 -0.109597       NaN
  32. c  1.273388 -0.167123  0.640382
  33. b -0.098217  0.009797 -1.299504
  34. a       NaN -1.152244  0.562973
  35.  
  36. In [296]: unsorted_df.sort_index(axis=1)
  37. Out[296]: 
  38.         one     three       two
  39. a  0.562973       NaN -1.152244
  40. d       NaN -0.252916 -0.109597
  41. c  0.640382  1.273388 -0.167123
  42. b -1.299504 -0.098217  0.009797
  43.  
  44. # Series
  45. In [297]: unsorted_df['three'].sort_index()
  46. Out[297]: 
  47. a         NaN
  48. b   -0.098217
  49. c    1.273388
  50. d   -0.252916
  51. Name: three, dtype: float64

按值排序

Series.sort_values() 方法用于按值对 Series 排序。DataFrame.sort_values() 方法用于按行列的值对 DataFrame 排序。DataFrame.sort_values() 的可选参数 by 用于指定按哪列排序，该参数的值可以是一列或多列数据。

  1. In [298]: df1 = pd.DataFrame({'one': [2, 1, 1, 1],
  2.    .....:                     'two': [1, 3, 2, 4],
  3.    .....:                     'three': [5, 4, 3, 2]})
  4.    .....: 
  5.  
  6. In [299]: df1.sort_values(by='two')
  7. Out[299]: 
  8.    one  two  three
  9. 0    2    1      5
  10. 2    1    2      3
  11. 1    1    3      4
  12. 3    1    4      2

参数 by 支持列名列表，示例如下：

  1. In [300]: df1[['one', 'two', 'three']].sort_values(by=['one', 'two'])
  2. Out[300]: 
  3.    one  two  three
  4. 2    1    2      3
  5. 1    1    3      4
  6. 3    1    4      2
  7. 0    2    1      5

这些方法支持用 na_position 参数处理空值。

  1. In [301]: s[2] = np.nan
  2.  
  3. In [302]: s.sort_values()
  4. Out[302]: 
  5. 0       A
  6. 3    Aaba
  7. 1       B
  8. 4    Baca
  9. 6    CABA
  10. 8     cat
  11. 7     dog
  12. 2     NaN
  13. 5     NaN
  14. dtype: object
  15.  
  16. In [303]: s.sort_values(na_position='first')
  17. Out[303]: 
  18. 2     NaN
  19. 5     NaN
  20. 0       A
  21. 3    Aaba
  22. 1       B
  23. 4    Baca
  24. 6    CABA
  25. 8     cat
  26. 7     dog
  27. dtype: object

按索引与值排序

0.23.0 版新增。

通过参数 by 传递给 DataFrame.sort_values() 的字符串可以引用列或索引层名。

  1. # 创建 MultiIndex
  2. In [304]: idx = pd.MultiIndex.from_tuples([('a', 1), ('a', 2), ('a', 2),
  3.    .....:                                 ('b', 2), ('b', 1), ('b', 1)])
  4.    .....: 
  5.  
  6. In [305]: idx.names = ['first', 'second']
  7.  
  8. # 创建 DataFrame
  9. In [306]: df_multi = pd.DataFrame({'A': np.arange(6, 0, -1)},
  10.    .....:                         index=idx)
  11.    .....: 
  12.  
  13. In [307]: df_multi
  14. Out[307]: 
  15.               A
  16. first second   
  17. a     1       6
  18.       2       5
  19.       2       4
  20. b     2       3
  21.       1       2
  22.       1       1

按 second（索引）与 A（列）排序。

  1. In [308]: df_multi.sort_values(by=['second', 'A'])
  2. Out[308]: 
  3.               A
  4. first second   
  5. b     1       1
  6.       1       2
  7. a     1       6
  8. b     2       3
  9. a     2       4
  10.       2       5

::: tip 注意

如果字符串、列名、索引层名重名，会触发警告提示，并以列名为准。后期版本中，这种情况将会触发模糊错误。

:::

搜索排序

Series 支持 searchsorted() 方法，这与numpy.ndarray.searchsorted() 的操作方式类似。

  1. In [309]: ser = pd.Series([1, 2, 3])
  2.  
  3. In [310]: ser.searchsorted([0, 3])
  4. Out[310]: array([0, 2])
  5.  
  6. In [311]: ser.searchsorted([0, 4])
  7. Out[311]: array([0, 3])
  8.  
  9. In [312]: ser.searchsorted([1, 3], side='right')
  10. Out[312]: array([1, 3])
  11.  
  12. In [313]: ser.searchsorted([1, 3], side='left')
  13. Out[313]: array([0, 2])
  14.  
  15. In [314]: ser = pd.Series([3, 1, 2])
  16.  
  17. In [315]: ser.searchsorted([0, 3], sorter=np.argsort(ser))
  18. Out[315]: array([0, 2])

最大值与最小值

Series 支持 nsmallest() 与 nlargest() 方法，本方法返回 N 个最大或最小的值。对于数据量大的 Series 来说，该方法比先为整个 Series 排序，再调用 head(n) 这种方式的速度要快得多。

  1. In [316]: s = pd.Series(np.random.permutation(10))
  2.  
  3. In [317]: s
  4. Out[317]: 
  5. 0    2
  6. 1    0
  7. 2    3
  8. 3    7
  9. 4    1
  10. 5    5
  11. 6    9
  12. 7    6
  13. 8    8
  14. 9    4
  15. dtype: int64
  16.  
  17. In [318]: s.sort_values()
  18. Out[318]: 
  19. 1    0
  20. 4    1
  21. 0    2
  22. 2    3
  23. 9    4
  24. 5    5
  25. 7    6
  26. 3    7
  27. 8    8
  28. 6    9
  29. dtype: int64
  30.  
  31. In [319]: s.nsmallest(3)
  32. Out[319]: 
  33. 1    0
  34. 4    1
  35. 0    2
  36. dtype: int64
  37.  
  38. In [320]: s.nlargest(3)
  39. Out[320]: 
  40. 6    9
  41. 8    8
  42. 3    7
  43. dtype: int64

DataFrame 也支持 nlargest 与 nsmallest 方法。

  1. In [321]: df = pd.DataFrame({'a': [-2, -1, 1, 10, 8, 11, -1],
  2.    .....:                    'b': list('abdceff'),
  3.    .....:                    'c': [1.0, 2.0, 4.0, 3.2, np.nan, 3.0, 4.0]})
  4.    .....: 
  5.  
  6. In [322]: df.nlargest(3, 'a')
  7. Out[322]: 
  8.     a  b    c
  9. 5  11  f  3.0
  10. 3  10  c  3.2
  11. 4   8  e  NaN
  12.  
  13. In [323]: df.nlargest(5, ['a', 'c'])
  14. Out[323]: 
  15.     a  b    c
  16. 5  11  f  3.0
  17. 3  10  c  3.2
  18. 4   8  e  NaN
  19. 2   1  d  4.0
  20. 6  -1  f  4.0
  21.  
  22. In [324]: df.nsmallest(3, 'a')
  23. Out[324]: 
  24.    a  b    c
  25. 0 -2  a  1.0
  26. 1 -1  b  2.0
  27. 6 -1  f  4.0
  28.  
  29. In [325]: df.nsmallest(5, ['a', 'c'])
  30. Out[325]: 
  31.    a  b    c
  32. 0 -2  a  1.0
  33. 1 -1  b  2.0
  34. 6 -1  f  4.0
  35. 2  1  d  4.0
  36. 4  8  e  NaN

用多重索引的列排序

列为多重索引时，还可以显式排序，用 by 可以指定所有层级。

  1. In [326]: df1.columns = pd.MultiIndex.from_tuples([('a', 'one'),
  2.    .....:                                          ('a', 'two'),
  3.    .....:                                          ('b', 'three')])
  4.    .....: 
  5.  
  6. In [327]: df1.sort_values(by=('a', 'two'))
  7. Out[327]: 
  8.     a         b
  9.   one two three
  10. 0   2   1     5
  11. 2   1   2     3
  12. 1   1   3     4
  13. 3   1   4     2

复制

在 pandas 对象上执行 copy() 方法，将复制底层数据（但不包括轴索引，因为轴索引不可变），并返回一个新的对象。注意，复制对象这种操作一般来说不是必须的。比如说，以下几种方式可以就地（inplace） 改变 DataFrame：

  • 插入、删除、修改列

  • 为 index 或 columns 属性赋值

  • 对于同质数据，用 values 属性或高级索引即可直接修改值

注意，用 pandas 方法修改数据不会带来任何副作用，几乎所有方法都返回新的对象，不会修改原始数据对象。如果原始数据有所改动，唯一的可能就是用户显式指定了要修改原始数据。

大家好，我是老表
觉得本文不错的话，转发、留言、点赞，是对我最大的支持。

每日留言

说说你读完本文感受？

或者一句激励自己的话？

（字数不少于15字）

留言赠书

《深入浅出Python机器学习》

点击视频查看书籍介绍

长按扫码查看书籍详情

怎么加入刻意学习队伍

点我，看文末彩蛋

留言有啥福利

点我就知道了

想进学习交流群

加微信：jjxksa888

备注：简说Python

2小时快速掌握Python基础知识要点。

完整Python基础知识要点

Python小知识 | 这些技能你不会?(一)

Python小知识 | 这些技能你不会?(二)

Python小知识 | 这些技能你不会?(三)

Python小知识 | 这些技能你不会?(四)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/193646
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号