pandas快速入门

numpy之后让我们紧接着学习pandas。Pandas最初被作为金融数据分析工具而开发出来，后来因为其强大性以及友好性，在数据分析领域被广泛使用，下面让我们一窥究竟。

本文参考官网给出的10 Minutes to pandas

对象创建

创建Series

  1. #创建Series对象，index参数可省，默认为0~n-1的数字索引
  2. #与numpy中的array一样，统一Series要求数据类型一致，这样可以加快处理速度
  3. In [12]: s = pd.Series([1,2,3,np.nan,5,7],index=list('ABCDEF'))
  5. In [13]: s
  6. Out[13]:
  7. A    1.0
  8. B    2.0
  9. C    3.0
  10. D    NaN
  11. E    5.0
  12. F    7.0
  13. dtype: float64

创建dataFrame

1.使用numpy array创建

  1. In [4]: dates = pd.date_range('20170909',periods=6) #pandas对于时间的处理也很出色
  3. In [5]: dates
  4. Out[5]:
  5. DatetimeIndex(['2017-09-09', '2017-09-10', '2017-09-11', '2017-09-12',
  6.                '2017-09-13', '2017-09-14'],
  7.               dtype='datetime64[ns]', freq='D')
  9. In [6]: df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=list('ABCD'))
  10.    ...: #pd.DataFrame(数组, 行索引(可省), 列索引一般不省略)
  12. In [7]: df
  13. Out[7]:
  14.                    A         B         C         D
  15. 2017-09-09 -0.874363 -0.682658  0.533449 -0.396235
  16. 2017-09-10  0.878331  0.825946  1.075934 -0.820331
  17. 2017-09-11  0.720920  0.095851 -1.521827  1.252951
  18. 2017-09-12 -1.338117  0.787224  0.450896  0.586154
  19. 2017-09-13  0.954178 -0.475164  0.356891 -1.428600
  20. 2017-09-14  1.081780  0.846195 -0.070906 -0.805635

2.使用字典创建

  1. df2 = pd.DataFrame({ 'A':[1,2,3],
  2.                      'B':[3,4,5],
  3.                      'C':np.arange(3)
  4.         })
  5. print df2
  7.    A  B  C
  8. 0  1  3  0
  9. 1  2  4  1
  10. 2  3  5  2

网上使用多种数据类型也是可以的，博主认为同种类型更加常用一点吧

查看数据类型与numpy一样，是

df.dtypes

完成创建后，列将作为df的属性，可以通过df.A直接访问列

查看数据

查看数据就需要数据，博主这里使用的数据样例是之前爬取的中国城市历史天气

  1. In [41]: df = pd.read_csv('./weather.csv')
  3. In [42]: df.head(10) #这里取前10条记录，默认为5条
  4. Out[42]:
  5.    city      pinYin  rainy  cloudy  sunny  overcast  snowy
  6. 0    阿城      acheng    563     761    809         8    215
  7. 1  昂昂溪区  angangxiqu    158     474    213        28     29
  8. 2   爱民区     aiminqu    269     304    253        17     72
  9. 3    安达        anda    523     977    700         0    169
  10. 4    安图        antu    580     868    704         2    219
  11. 5    鞍山      anshan    504     736    988         3    133
  12. 6   阿鲁旗       aluqi    445     821    935        54    120
  13. 7    敖汉       aohan    462     821    928        48    109
  14. 8   阿巴嘎       abaga    363     694   1086        54    169
  15. 9   阿荣旗     arongqi    522     942    624        74    212
  17. ...
  18. In [47]: df.tail() #tail同理
  19. Out[47]:
  20.      city      pinYin  rainy  cloudy  sunny  overcast  snowy
  21. 3200   资源      ziyuan   1230     824    199        95     23
  22. 3201   昭平    zhaoping   1333     845    131        61      0
  23. 3202   钟山  zhongshan1   1317     861    131        63      0
  24. 3203  昭平区  zhaopingqu    467     326     66        38      0
  25. 3204   彰化    zhanghua   1241     472     93       117      0

查看元数据

  1. In [48]: df.index #行属性
  2. Out[48]: RangeIndex(start=0, stop=3205, step=1)
  4. In [49]: df.columns #列属性
  5. Out[49]:
  6. Index([u'city', u'pinYin', u'rainy', u'cloudy', u'sunny', u'overcast',
  7.        u'snowy'],
  8.       dtype='object')
  10. #统计数据，只会对数值类的进行计算
  11. In [51]: df.describe()
  12. Out[51]:
  13.              rainy       cloudy        sunny     overcast        snowy
  14. count  3205.000000  3205.000000  3205.000000  3205.000000  3205.000000
  15. mean    651.232137   797.288300   423.981591   104.118565    62.204680
  16. std     344.324084   292.436344   302.132459    90.538331    81.090957
  17. min       0.000000     0.000000     0.000000     0.000000     0.000000
  18. 25%     404.000000   596.000000   174.000000    43.000000     9.000000
  19. 50%     543.000000   855.000000   326.000000    86.000000    39.000000
  20. 75%     957.000000   991.000000   668.000000   136.000000    74.000000
  21. max    1775.000000  1761.000000  1424.000000   614.000000   726.000000

另外，df.T求转置

排序

  1. In [64]: df.sort_values(by='sunny',ascending=False).head()
  2. Out[64]:
  3.       city        pinYin  rainy  cloudy  sunny  overcast  snowy
  4. 356     磴口       dengkou    221     675   1424         6     33
  5. 2418   乌后旗       wuhouqi    174     718   1421         8     29
  6. 790   杭锦后旗  hangjinhouqi    204     694   1421        11     28
  7. 508    额济纳         ejina     75     761   1405        30     17
  8. 2415    五原        wuyuan    234     675   1405         6     38

选择数据

基本操作(不推荐)

  1. df['city'] #列选择，跟df.city一样
  2. df[0:3] #行选择
  • 通过标签选择
  1. In [74]: df.loc[0:5,['city','rainy']]
  2. Out[74]:
  3.    city  rainy
  4. 0    阿城    563
  5. 1  昂昂溪区    158
  6. 2   爱民区    269
  7. 3    安达    523
  8. 4    安图    580
  9. 5    鞍山    504
  10. #如果只选择一个标量，用at可以加速
  11. In [79]: df.at[2,'snowy']
  12. Out[79]: 72
  • 通过位置(整数)索引
  1. #单行记录
  2. In [80]: df.iloc[2]
  3. Out[80]:
  4. city            爱民区
  5. pinYin      aiminqu
  6. rainy           269
  7. cloudy          304
  8. sunny           253
  9. overcast         17
  10. snowy            72
  11. Name: 2, dtype: object
  13. #中间切片
  14. In [82]: df.iloc[3:6]
  15. Out[82]:
  16.   city  pinYin  rainy  cloudy  sunny  overcast  snowy
  17. 3   安达    anda    523     977    700         0    169
  18. 4   安图    antu    580     868    704         2    219
  19. 5   鞍山  anshan    504     736    988         3    133
  21. #取指定一个属性
  22. In [83]: df.iloc[3:6,[2,4]]
  23. Out[83]:
  24.    rainy  sunny
  25. 3    523    700
  26. 4    580    704
  27. 5    504    988
  28. #同样，如果只选择一个标量，用at可以加速
  29. In [84]: df.iloc[3,3]
  30. Out[84]: 977
  32. In [85]: df.iat[3,3]
  33. Out[85]: 977
  • 布尔索引
  1. In [92]: df[df.cloudy>1600]
  2. Out[92]:
  3.      city       pinYin  rainy  cloudy  sunny  overcast  snowy
  4. 493    东方     dongfang    555    1761      3        58      0
  5. 841    哈密         hami    107    1752    467         0     44
  6. 2249   三亚        sanya    722    1621     16        18      0
  7. 2870   伊吾         yiwu    170    1627    466         1    110
  8. 2913  宜昌县  yichangxian    469    1667    121        80     19
  10. #集合包含可以用isin来过滤
  11. In [95]: df[df.snowy.isin([0,1,2,3,4,5])]

设置新值

1.通过Series添加新列

  1. In [45]: s1 = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130102', periods=6))
  2. In [47]: df['F'] = s1

2.直接修改数据项

  1. In [48]: df.at[dates[0],'A'] = 0
  2. In [49]: df.iat[0,1] = 0
  3. In [50]: df.loc[:,'D'] = np.array([5] * len(df))
  5. #更高阶技巧
  6. In [52]: df2 = df.copy()
  7. In [53]: df2[df2 > 0] = -df2

处理缺失值nan

  1. In [58]: df1.dropna(how='any') #删除有确实的记录
  2. In [59]: df1.fillna(value=n5) #用默认值填充
  3. In [60]: pd.isnull(df1) #返回布尔矩阵，找出有nan的位置

相关操作

统计

  1. In [61]: df.mean() #对每一列进行统计
  2. Out[61]:
  3. A   -0.004474
  4. B   -0.383981
  5. C   -0.687758
  6. D    5.000000
  7. F    3.000000
  8. dtype: float64
  10. In [62]: df.mean(1) #横轴统计
  11. Out[62]:
  12. 2013-01-01    0.872735
  13. 2013-01-02    1.431621
  14. 2013-01-03    0.707731
  15. 2013-01-04    1.395042
  16. 2013-01-05    1.883656
  17. 2013-01-06    1.592306
  18. Freq: D, dtype: float64

Apply定制函数

  1. In [66]: df.apply(np.cumsum)
  2. Out[66]:
  3.                    A         B         C   D     F
  4. 2013-01-01  0.000000  0.000000 -1.509059   5   NaN
  5. 2013-01-02  1.212112 -0.173215 -1.389850  10   1.0
  6. 2013-01-03  0.350263 -2.277784 -1.884779  15   3.0
  7. 2013-01-04  1.071818 -2.984555 -2.924354  20   6.0
  8. 2013-01-05  0.646846 -2.417535 -2.648122  25  10.0
  9. 2013-01-06 -0.026844 -2.303886 -4.126549  30  15.0
  11. In [67]: df.apply(lambda x: x.max() - x.min())
  12. Out[67]:
  13. A    2.073961
  14. B    2.671590
  15. C    1.785291
  16. D    0.000000
  17. F    4.000000
  18. dtype: float64

直方图统计

  1. In [102]: df.cloudy.value_counts() #对于Series进行计数统计

字符串操作

  1. #字符串的操作权包含在 str里面，也是对于Series
  2. In [104]: df.pinYin.str.upper()

合并

concat

  1. In [106]: df
  2. Out[106]:
  3.    0  1  2  3
  4. 0  3  1  3  8
  5. 1  9  8  5  1
  6. 2  1  8  5  2
  7. 3  9  6  8  3
  8. 4  7  2  6  8
  9. 5  5  8  1  2
  10. 6  7  3  9  1
  11. 7  1  1  9  4
  12. 8  3  5  9  5
  13. 9  9  2  9  1
  15. In [107]: pieces = [df[:3],df[3:7],df[7:]]
  17. In [108]: pieces
  18. Out[108]:
  19. [   0  1  2  3
  20.  0  3  1  3  8
  21.  1  9  8  5  1
  22.  2  1  8  5  2,    0  1  2  3
  23.  3  9  6  8  3
  24.  4  7  2  6  8
  25.  5  5  8  1  2
  26.  6  7  3  9  1,    0  1  2  3
  27.  7  1  1  9  4
  28.  8  3  5  9  5
  29.  9  9  2  9  1]
  31. In [109]: pd.concat(pieces,axis=1)
  32. Out[109]:
  33.      0    1    2    3    0    1    2    3    0    1    2    3
  34. 0  3.0  1.0  3.0  8.0  NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
  35. 1  9.0  8.0  5.0  1.0  NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
  36. 2  1.0  8.0  5.0  2.0  NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
  37. 3  NaN  NaN  NaN  NaN  9.0  6.0  8.0  3.0  NaN  NaN  NaN  NaN
  38. 4  NaN  NaN  NaN  NaN  7.0  2.0  6.0  8.0  NaN  NaN  NaN  NaN
  39. 5  NaN  NaN  NaN  NaN  5.0  8.0  1.0  2.0  NaN  NaN  NaN  NaN
  40. 6  NaN  NaN  NaN  NaN  7.0  3.0  9.0  1.0  NaN  NaN  NaN  NaN
  41. 7  NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN  1.0  1.0  9.0  4.0
  42. 8  NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN  3.0  5.0  9.0  5.0
  43. 9  NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN  9.0  2.0  9.0  1.0
  45. In [110]: pd.concat(pieces,axis=0)
  46. Out[110]:
  47.    0  1  2  3
  48. 0  3  1  3  8
  49. 1  9  8  5  1
  50. 2  1  8  5  2
  51. 3  9  6  8  3
  52. 4  7  2  6  8
  53. 5  5  8  1  2
  54. 6  7  3  9  1
  55. 7  1  1  9  4
  56. 8  3  5  9  5
  57. 9  9  2  9  1

join

与SQL中的join一致，调用的是merge方法

  1. #key出现重复，所以直接使用笛卡尔积
  2. In [114]: left = pd.DataFrame({'key':['a','a'],'value':[1,2]})
  4. In [115]: right = pd.DataFrame({'key':['a','a'],'value':[3,4]})
  6. In [116]: pd.merge(left, right, on='key')
  7. Out[116]:
  8.   key  value_x  value_y
  9. 0   a        1        3
  10. 1   a        1        4
  11. 2   a        2        3
  12. 3   a        2        4
  14. #on的key是unique则去重进行join
  15. In [117]: right = pd.DataFrame({'key':['a','b'],'value':[3,4]})
  17. In [118]: left = pd.DataFrame({'key':['a','b'],'value':[1,2]})
  19. In [120]: pd.merge(left,right,on='key')
  20. Out[120]:
  21.   key  value_x  value_y
  22. 0   a        1        3
  23. 1   b        2        4

append

添加一条记录

  1. In [87]: df = pd.DataFrame(np.random.randn(8, 4), columns=['A','B','C','D'])
  3. In [88]: df
  4. Out[88]:
  5.           A         B         C         D
  6. 0  1.346061  1.511763  1.627081 -0.990582
  7. 1 -0.441652  1.211526  0.268520  0.024580
  8. 2 -1.577585  0.396823 -0.105381 -0.532532
  9. 3  1.453749  1.208843 -0.080952 -0.264610
  10. 4 -0.727965 -0.589346  0.339969 -0.693205
  11. 5 -0.339355  0.593616  0.884345  1.591431
  12. 6  0.141809  0.220390  0.435589  0.192451
  13. 7 -0.096701  0.803351  1.715071 -0.708758
  15. In [89]: s = df.iloc[3]
  17. In [90]: df.append(s, ignore_index=True)
  18. Out[90]:
  19.           A         B         C         D
  20. 0  1.346061  1.511763  1.627081 -0.990582
  21. 1 -0.441652  1.211526  0.268520  0.024580
  22. 2 -1.577585  0.396823 -0.105381 -0.532532
  23. 3  1.453749  1.208843 -0.080952 -0.264610
  24. 4 -0.727965 -0.589346  0.339969 -0.693205
  25. 5 -0.339355  0.593616  0.884345  1.591431
  26. 6  0.141809  0.220390  0.435589  0.192451
  27. 7 -0.096701  0.803351  1.715071 -0.708758
  28. 8  1.453749  1.208843 -0.080952 -0.264610
  30. #注意添加的记录数据类型是Series
  31. In [124]: s
  32. Out[124]:
  33. A    0.077384
  34. B   -0.716115
  35. C    0.427943
  36. D    0.057282
  37. Name: 3, dtype: float64

分组

  1. In [91]: df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
  2.    ....:                           'foo', 'bar', 'foo', 'foo'],
  3.    ....:                    'B' : ['one', 'one', 'two', 'three',
  4.    ....:                           'two', 'two', 'one', 'three'],
  5.    ....:                    'C' : np.random.randn(8),
  6.    ....:                    'D' : np.random.randn(8)})
  7.    ....: 
  9. In [92]: df
  10. Out[92]:
  11.      A      B         C         D
  12. 0  foo    one -1.202872 -0.055224
  13. 1  bar    one -1.814470  2.395985
  14. 2  foo    two  1.018601  1.552825
  15. 3  bar  three -0.595447  0.166599
  16. 4  foo    two  1.395433  0.047609
  17. 5  bar    two -0.392670 -0.136473
  18. 6  foo    one  0.007207 -0.561757
  19. 7  foo  three  1.928123 -1.623033
  21. In [93]: df.groupby('A').sum()
  22. Out[93]:
  23.             C        D
  24. A
  25. bar -2.802588  2.42611
  26. foo  3.146492 -0.63958
  27. #也可以使用其他函数 如
  28. #df.groupby('A').apply(np.sum)

作图

  1. In [135]: ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))
  3. In [136]: ts = ts.cumsum()
  5. In [137]: ts.plot()
  6. Out[137]: <matplotlib.axes._subplots.AxesSubplot at 0x1187d7278>
  7. In [138]: plt.show()
  8. #以Index为横坐标，其他值为纵坐标作图

小结

pandas还有很多高级用法，博主也在学习中，以上只列出比较常用的。

根据二八定理，差不多可以开始使用pandas愉快地处理数据了，其他的高级用法就即用即查吧，欢迎大家讨论交流。

pandas快速入门的更多相关文章

  1. Python pandas快速入门

    Python pandas快速入门2017年03月14日 17:17:52 青盏 阅读数:14292 标签: python numpy 数据分析 更多 个人分类: machine learning 来 ...

  2. Pandas 快速入门（二）

    本文的例子需要一些特殊设置,具体可以参考 Pandas快速入门(一) 数据清理和转换 我们在进行数据处理时,拿到的数据可能不符合我们的要求.有很多种情况,包括部分数据缺失,一些数据的格式不正确,一些数 ...

  3. Pandas快速入门笔记

    我正以Python作为突破口,入门机器学习相关知识.出于机器学习实践过程中的需要,我快速了解了一下提供了类似关系型或标签型数据结构的Pandas的使用方法.下面记录相关学习笔记. 数据结构 Panda ...

  4. Pandas快速入门（一）

    快速使用 bogon:Documents rousseau$ ipython --pylab Python 3.6.0 (v3.6.0:41df79263a11, Dec 22 2016, 17:23 ...

  5. Pandas快速入门（深度学习入门2）

    源地址为:http://pandas.pydata.org/pandas-docs/stable/10min.html#min Pandas(Python Data Analysis Library) ...

  6. pandas教程1：pandas数据结构入门

    pandas是一个用于进行python科学计算的常用库,包含高级的数据结构和精巧的工具,使得在Python中处理数据非常快速和简单.pandas建造在NumPy之上,它使得以NumPy为中心的应用很容 ...

  7. Jupyter 快速入门——写python项目博客非常有用！！！

    from:https://blog.csdn.net/m0_37338590/article/details/78862488 一.简介: Jupyter Notebook(此前被称为 IPython ...

  8. python快速入门——进入数据挖掘你该有的基础知识

    这篇文章是用来总结python中重要的语法,通过这些了解你可以快速了解一段python代码的含义 Python 的基础语法来带你快速入门 Python 语言.如果你想对 Python 有全面的了解请关 ...

  9. [Python]Pandas简单入门（转）

    本篇文章转自 https://colab.research.google.com/notebooks/mlcc/intro_to_pandas.ipynb?hl=zh-cn#scrollTo=zCOn ...

随机推荐

  1. Git强制拉取覆盖本地

    1.多条执行 git fetch --all git reset --hard origin/master git pull 2.单条执行 git fetch --all && git ...

  2. 新版的K8S中的flannel.yaml文件中要注意的细节

    部署flannel作为k8s中的网络插件,yaml文件都大小同异. 但在要注意以下细节. 以前,只需要前面master判断. 现在也需要有not-ready状态了. tolerations: - ke ...

  3. EF分别使用IQueryable和IEnumerable实现更新和删除

    缺点 使用IQueryable无法跟踪,无法监控sql,无法使用SaveChanges(). 优点 使用IQueryable简单粗暴. class Program { static void Main ...

  4. springboot1.5.4 集成cxf完整实例

    WebService 服务端 添加依赖 <?xml version="1.0" encoding="UTF-8"?> <project xml ...

  5. alpha冲刺8/10

    目录 摘要 团队部分 个人部分 摘要 队名:小白吃 组长博客:hjj 作业博客:冲刺倒计时之8 团队部分 后敬甲(组长) 过去两天完成了哪些任务 首页重新设计 课程时间线确定 答辩准备 接下来的计划 ...

  6. aop日志记录

    1.自定义 package cc.mrbird.common.annotation; import java.lang.annotation.ElementType; import java.lang ...

  7. Centos7创建CA和申请证书

    转载:http://rackie386.blog.51cto.com/11279229/1947999 Centos7.3创建CA和申请证书 openssl 的配置文件:/etc/pki/tls/op ...

  8. 分解数据表(将一个datatable按数据量分隔成多个table)

    /// <summary> /// 分解数据表 /// </summary> /// <param name="originalTab">需要分 ...

  9. python中sqlite问题和坑

    import sqlite3 #导入模块 conn = sqlite3.connect('example.db') C=conn.cursor() #创建表 C.execute('''CREATE T ...

  10. XamarinAndroid组件教程设置自定义子元素动画(一)

    XamarinAndroid组件教程设置自定义子元素动画(一) 如果在RecyclerViewAnimators.Animators中没有所需要的动画效果,就可以自定义一个.此时,需要让自定义的动画继 ...