【译】10分钟学会Pandas

方式壹:灵魂之问

异常钟学会Pandas

这是有关Pandas的简易介绍首要面向新用户。你能够参见Cookbook精晓更复杂的选择办法

习感觉常上,大家那样导入:

In [1]: import pandas as pd

In [2]: import numpy as np

In [3]: import matplotlib.pyplot as plt

例如:

成立对象

请参阅数据结构简单介绍部分

透过传递多少个列表的值创建一个Series,让Pandas创立一个默许的平头索引:

In [4]: s = pd.Series([1,3,5,np.nan,6,8])

In [5]: s
Out[5]: 
0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

因此传递的numpy数组创设三个DataFrame,并行使DataFrame索引和标识列:

In [6]: dates = pd.date_range('20130101', periods=6)

In [7]: dates
Out[7]: 
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',
               '2013-01-05', '2013-01-06'],
              dtype='datetime64[ns]', freq='D')

In [8]: df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))

In [9]: df
Out[9]: 
                   A         B         C         D
2013-01-01  0.469112 -0.282863 -1.509059 -1.135632
2013-01-02  1.212112 -0.173215  0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804
2013-01-04  0.721555 -0.706771 -1.039575  0.271860
2013-01-05 -0.424972  0.567020  0.276232 -1.087401
2013-01-06 -0.673690  0.113648 -1.478427  0.524988

因而传递可调换到类似系列结构的字典系列来创制DataFrame。

翻开分歧列的数据类型

In [12]: df2.dtypes
Out[12]: 
A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object

借使你使用的是IPython,能够选取Tab自动补全列名称(以及公共性质)。以下是将要完毕的习性的2个子集:

In [13]: df2.<TAB>
df2.A                  df2.bool
df2.abs                df2.boxplot
df2.add                df2.C
df2.add_prefix         df2.clip
df2.add_suffix         df2.clip_lower
df2.align              df2.clip_upper
df2.all                df2.columns
df2.any                df2.combine
df2.append             df2.combine_first
df2.apply              df2.compound
df2.applymap           df2.consolidate
df2.as_blocks          df2.convert_objects
df2.asfreq             df2.copy
df2.as_matrix          df2.corr
df2.astype             df2.corrwith
df2.at                 df2.count
df2.at_time            df2.cov
df2.axes               df2.cummax
df2.B                  df2.cummin
df2.between_time       df2.cumprod
df2.bfill              df2.cumsum
df2.blocks             df2.D

像你见到的那么,A、B、C、D都以选用Tab自动补全的。E也是如此;为了简洁别的的天性被截断了。

佛塔:“怎么样让动物从生老病死的大循环中脱身?”

查阅数据

请参阅基础部分

翻看frame中头部和尾巴的行

In [14]: df.head()
Out[14]: 
                   A         B         C         D
2013-01-01  0.469112 -0.282863 -1.509059 -1.135632
2013-01-02  1.212112 -0.173215  0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804
2013-01-04  0.721555 -0.706771 -1.039575  0.271860
2013-01-05 -0.424972  0.567020  0.276232 -1.087401

In [15]: df.tail(3)
Out[15]: 
                   A         B         C         D
2013-01-04  0.721555 -0.706771 -1.039575  0.271860
2013-01-05 -0.424972  0.567020  0.276232 -1.087401
2013-01-06 -0.673690  0.113648 -1.478427  0.524988

体现索引、行和尾巴部分numpy数据

In [16]: df.index
Out[16]: 
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',
               '2013-01-05', '2013-01-06'],
              dtype='datetime64[ns]', freq='D')

In [17]: df.columns
Out[17]: Index(['A', 'B', 'C', 'D'], dtype='object')

In [18]: df.values
Out[18]: 
array([[ 0.4691, -0.2829, -1.5091, -1.1356],
       [ 1.2121, -0.1732,  0.1192, -1.0442],
       [-0.8618, -2.1046, -0.4949,  1.0718],
       [ 0.7216, -0.7068, -1.0396,  0.2719],
       [-0.425 ,  0.567 ,  0.2762, -1.0874],
       [-0.6737,  0.1136, -1.4784,  0.525 ]])

来得你的多少的异常快总括摘要

In [19]: df.describe()
Out[19]: 
              A         B         C         D
count  6.000000  6.000000  6.000000  6.000000
mean   0.073711 -0.431125 -0.687758 -0.233103
std    0.843157  0.922818  0.779887  0.973118
min   -0.861849 -2.104569 -1.509059 -1.135632
25%   -0.611510 -0.600794 -1.368714 -1.076610
50%    0.022070 -0.228039 -0.767252 -0.386188
75%    0.658444  0.041933 -0.034326  0.461706

多少转置

In [20]: df.T
Out[20]: 
   2013-01-01  2013-01-02  2013-01-03  2013-01-04  2013-01-05  2013-01-06
A    0.469112    1.212112   -0.861849    0.721555   -0.424972   -0.673690
B   -0.282863   -0.173215   -2.104569   -0.706771    0.567020    0.113648
C   -1.509059    0.119209   -0.494929   -1.039575    0.276232   -1.478427
D   -1.135632   -1.044236    1.071804    0.271860   -1.087401    0.524988

按轴排序

In [21]: df.sort_index(axis=1, ascending=False)
Out[21]: 
                   D         C         B         A
2013-01-01 -1.135632 -1.509059 -0.282863  0.469112
2013-01-02 -1.044236  0.119209 -0.173215  1.212112
2013-01-03  1.071804 -0.494929 -2.104569 -0.861849
2013-01-04  0.271860 -1.039575 -0.706771  0.721555
2013-01-05 -1.087401  0.276232  0.567020 -0.424972
2013-01-06  0.524988 -1.478427  0.113648 -0.673690

按值排序

In [22]: df.sort_values(by='B')
Out[22]: 
                   A         B         C         D
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804
2013-01-04  0.721555 -0.706771 -1.039575  0.271860
2013-01-01  0.469112 -0.282863 -1.509059 -1.135632
2013-01-02  1.212112 -0.173215  0.119209 -1.044236
2013-01-06 -0.673690  0.113648 -1.478427  0.524988
2013-01-05 -0.424972  0.567020  0.276232 -1.087401

苏格拉底:“智慧是怎么着,以及自小编毕竟知道哪些?”

选择

请参阅索引文档
目录和抉择数据

多索引/高档索引

王阳明:“圣人处此,更有什么道?”

读取

分选一个单身的列,重返2个Series,等同于 df.A

In [23]: df['A']
Out[23]: 
2013-01-01    0.469112
2013-01-02    1.212112
2013-01-03   -0.861849
2013-01-04    0.721555
2013-01-05   -0.424972
2013-01-06   -0.673690
Freq: D, Name: A, dtype: float64

使用[]挑选,对行举办切开。

In [24]: df[0:3]
Out[24]: 
                   A         B         C         D
2013-01-01  0.469112 -0.282863 -1.509059 -1.135632
2013-01-02  1.212112 -0.173215  0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804

In [25]: df['20130102':'20130104']
Out[25]: 
                   A         B         C         D
2013-01-02  1.212112 -0.173215  0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804
2013-01-04  0.721555 -0.706771 -1.039575  0.271860

爱因斯坦:“固然小编以光速的快慢发展,作者会看到怎么着?”

透过标签选择

端详参见标签选取

利用标签获取交叉区域

In [26]: df.loc[dates[0]]
Out[26]: 
A    0.469112
B   -0.282863
C   -1.509059
D   -1.135632
Name: 2013-01-01 00:00:00, dtype: float64

通过标签选用多轴

In [27]: df.loc[:,['A','B']]
Out[27]: 
                   A         B
2013-01-01  0.469112 -0.282863
2013-01-02  1.212112 -0.173215
2013-01-03 -0.861849 -2.104569
2013-01-04  0.721555 -0.706771
2013-01-05 -0.424972  0.567020
2013-01-06 -0.673690  0.113648

体现标签切成块,包蕴端点

In [28]: df.loc['20130102':'20130104',['A','B']]
Out[28]: 
                   A         B
2013-01-02  1.212112 -0.173215
2013-01-03 -0.861849 -2.104569
2013-01-04  0.721555 -0.706771

降落再次回到对象维度

In [29]: df.loc['20130102',['A','B']]
Out[29]: 
A    1.212112
B   -0.173215
Name: 2013-01-02 00:00:00, dtype: float64

获得标量值

In [30]: df.loc[dates[0],'A']
Out[30]: 0.46911229990718628

快捷访问标量(同上一主意等价)

In [31]: df.at[dates[0],'A']
Out[31]: 0.46911229990718628

稻盛和夫:“作为人何为不易?”

按岗位接纳

详细情况参见按任务接纳

经过传递整数采取地方

In [32]: df.iloc[3]
Out[32]: 
A    0.721555
B   -0.706771
C   -1.039575
D    0.271860
Name: 2013-01-04 00:00:00, dtype: float64

因而整数切块,类似于numpy/python

In [33]: df.iloc[3:5,0:2]
Out[33]: 
                   A         B
2013-01-04  0.721555 -0.706771
2013-01-05 -0.424972  0.567020

经过列表钦定地方,类似于numpy/python样式

In [34]: df.iloc[[1,2,4],[0,2]]
Out[34]: 
                   A         C
2013-01-02  1.212112  0.119209
2013-01-03 -0.861849 -0.494929
2013-01-05 -0.424972  0.276232

对行切丝

In [35]: df.iloc[1:3,:]
Out[35]: 
                   A         B         C         D
2013-01-02  1.212112 -0.173215  0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804

对列切成丝

In [36]: df.iloc[:,1:3]
Out[36]: 
                   B         C
2013-01-01 -0.282863 -1.509059
2013-01-02 -0.173215  0.119209
2013-01-03 -2.104569 -0.494929
2013-01-04 -0.706771 -1.039575
2013-01-05  0.567020  0.276232
2013-01-06  0.113648 -1.478427

获得钦赐值

In [37]: df.iloc[1,1]
Out[37]: -0.17321464905330858

迅速访问标量(同上一艺术等价)

In [38]: df.iat[1,1]
Out[38]: -0.17321464905330858

千面大学生:“集体意识是何许运维的?”(人生游戏表明书是什么?)

布尔索引

选取单列值选拔数据。

In [39]: df[df.A > 0]
Out[39]: 
                   A         B         C         D
2013-01-01  0.469112 -0.282863 -1.509059 -1.135632
2013-01-02  1.212112 -0.173215  0.119209 -1.044236
2013-01-04  0.721555 -0.706771 -1.039575  0.271860

从满足布尔条件的DataFrame中挑选值。

In [40]: df[df > 0]
Out[40]: 
                   A         B         C         D
2013-01-01  0.469112       NaN       NaN       NaN
2013-01-02  1.212112       NaN  0.119209       NaN
2013-01-03       NaN       NaN       NaN  1.071804
2013-01-04  0.721555       NaN       NaN  0.271860
2013-01-05       NaN  0.567020  0.276232       NaN
2013-01-06       NaN  0.113648       NaN  0.524988

使用isin()措施开始展览过滤

In [41]: df2 = df.copy()

In [42]: df2['E'] = ['one', 'one','two','three','four','three']

In [43]: df2
Out[43]: 
                   A         B         C         D      E
2013-01-01  0.469112 -0.282863 -1.509059 -1.135632    one
2013-01-02  1.212112 -0.173215  0.119209 -1.044236    one
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804    two
2013-01-04  0.721555 -0.706771 -1.039575  0.271860  three
2013-01-05 -0.424972  0.567020  0.276232 -1.087401   four
2013-01-06 -0.673690  0.113648 -1.478427  0.524988  three

In [44]: df2[df2['E'].isin(['two','four'])]
Out[44]: 
                   A         B         C         D     E
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804   two
2013-01-05 -0.424972  0.567020  0.276232 -1.087401  four

您的神魄之问是怎么样?

设置

设置三个新列会自动使索引对齐多少

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

In [46]: s1
Out[46]: 
2013-01-02    1
2013-01-03    2
2013-01-04    3
2013-01-05    4
2013-01-06    5
2013-01-07    6
Freq: D, dtype: int64

In [47]: df['F'] = s1

按标签切成片

In [48]: df.at[dates[0],'A'] = 0

按任务设置值

In [49]: df.iat[0,1] = 0

经过numpy数组织设立置

In [50]: df.loc[:,'D'] = np.array([5] * len(df))

安装结果如下

In [51]: df
Out[51]: 
                   A         B         C  D    F
2013-01-01  0.000000  0.000000 -1.509059  5  NaN
2013-01-02  1.212112 -0.173215  0.119209  5  1.0
2013-01-03 -0.861849 -2.104569 -0.494929  5  2.0
2013-01-04  0.721555 -0.706771 -1.039575  5  3.0
2013-01-05 -0.424972  0.567020  0.276232  5  4.0
2013-01-06 -0.673690  0.113648 -1.478427  5  5.0

where操作赋值

In [52]: df2 = df.copy()

In [53]: df2[df2 > 0] = -df2

In [54]: df2
Out[54]: 
                   A         B         C  D    F
2013-01-01  0.000000  0.000000 -1.509059 -5  NaN
2013-01-02 -1.212112 -0.173215 -0.119209 -5 -1.0
2013-01-03 -0.861849 -2.104569 -0.494929 -5 -2.0
2013-01-04 -0.721555 -0.706771 -1.039575 -5 -3.0
2013-01-05 -0.424972 -0.567020 -0.276232 -5 -4.0
2013-01-06 -0.673690 -0.113648 -1.478427 -5 -5.0

方式2:完形填空

缺失数据

Pandas首要运用np.nan来表示缺点和失误数据。暗中同意意况下不包含在测算中。请参阅缺失数据部分

重建索引允许修改/加多/删除钦定轴的目录,并赶回数据别本。

In [55]: df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ['E'])

In [56]: df1.loc[dates[0]:dates[1],'E'] = 1

In [57]: df1
Out[57]: 
                   A         B         C  D    F    E
2013-01-01  0.000000  0.000000 -1.509059  5  NaN  1.0
2013-01-02  1.212112 -0.173215  0.119209  5  1.0  1.0
2013-01-03 -0.861849 -2.104569 -0.494929  5  2.0  NaN
2013-01-04  0.721555 -0.706771 -1.039575  5  3.0  NaN

除去全数缺点和失误数据的行。

In [58]: df1.dropna(how='any')
Out[58]: 
                   A         B         C  D    F    E
2013-01-02  1.212112 -0.173215  0.119209  5  1.0  1.0

填写缺失的数据行

In [59]: df1.fillna(value=5)
Out[59]: 
                   A         B         C  D    F    E
2013-01-01  0.000000  0.000000 -1.509059  5  5.0  1.0
2013-01-02  1.212112 -0.173215  0.119209  5  1.0  1.0
2013-01-03 -0.861849 -2.104569 -0.494929  5  2.0  5.0
2013-01-04  0.721555 -0.706771 -1.039575  5  3.0  5.0

获取值为nan的布尔值

In [60]: pd.isnull(df1)
Out[60]: 
                A      B      C      D      F      E
2013-01-01  False  False  False  False   True  False
2013-01-02  False  False  False  False  False  False
2013-01-03  False  False  False  False  False   True
2013-01-04  False  False  False  False  False   True

直接法:

运算

请参阅二进制运算的功尾巴部分分

给本身三个相对来说很平静,未有侵扰的时刻段,一个钟头,准备几张大白纸,在大白纸的最顶端写上:笔者的重任是_______,然后就从头写,脑袋里冒出此外的想法就开端写,笔者的重任是,作者的职责是,作者的造化是,笔者那辈子想要做的是,那么就在那二个钟头之中无论如何一定要坐下来,让投机把那一个答案写出来。

统计

运算壹般排除丢失的多少。

实行描述性总括

In [61]: df.mean()
Out[61]: 
A   -0.004474
B   -0.383981
C   -0.687758
D    5.000000
F    3.000000
dtype: float64

在任何轴上实行一样的运算

In [62]: df.mean(1)
Out[62]: 
2013-01-01    0.872735
2013-01-02    1.431621
2013-01-03    0.707731
2013-01-04    1.395042
2013-01-05    1.883656
2013-01-06    1.592306
Freq: D, dtype: float64

运算具备差异维度和内需对齐的靶子。其它,Pandas会沿着钦赐维度运算。

In [63]: s = pd.Series([1,3,5,np.nan,6,8], index=dates).shift(2)

In [64]: s
Out[64]: 
2013-01-01    NaN
2013-01-02    NaN
2013-01-03    1.0
2013-01-04    3.0
2013-01-05    5.0
2013-01-06    NaN
Freq: D, dtype: float64

In [65]: df.sub(s, axis='index')
Out[65]: 
                   A         B         C    D    F
2013-01-01       NaN       NaN       NaN  NaN  NaN
2013-01-02       NaN       NaN       NaN  NaN  NaN
2013-01-03 -1.861849 -3.104569 -1.494929  4.0  1.0
2013-01-04 -2.278445 -3.706771 -4.039575  2.0  0.0
2013-01-05 -5.424972 -4.432980 -4.723768  0.0 -1.0
2013-01-06       NaN       NaN       NaN  NaN  NaN

本条方式需求很强的自制力,许多时候实在你的头颅里什么想法都写完了,这几个想法还是无法撼动您,不可能发自内心地震撼自身。相当于至极最深的答案出来的时候,平时会协调都能打动到温馨落泪也好,恐怕是1身发抖,可能是过电什么的,会有局地那样的反应,不然的话它就不是一个感动灵魂的答案了。

应用

将函数应用于数据

In [66]: df.apply(np.cumsum)
Out[66]: 
                   A         B         C   D     F
2013-01-01  0.000000  0.000000 -1.509059   5   NaN
2013-01-02  1.212112 -0.173215 -1.389850  10   1.0
2013-01-03  0.350263 -2.277784 -1.884779  15   3.0
2013-01-04  1.071818 -2.984555 -2.924354  20   6.0
2013-01-05  0.646846 -2.417535 -2.648122  25  10.0
2013-01-06 -0.026844 -2.303886 -4.126549  30  15.0

In [67]: df.apply(lambda x: x.max() - x.min())
Out[67]: 
A    2.073961
B    2.671590
C    1.785291
D    0.000000
F    4.000000
dtype: float64

间接法:

直方图

详细的情况请请参阅直方图和离散化

In [68]: s = pd.Series(np.random.randint(0, 7, size=10))

In [69]: s
Out[69]: 
0    4
1    2
2    1
3    2
4    6
5    4
6    4
7    6
8    4
9    4
dtype: int64

In [70]: s.value_counts()
Out[70]: 
4    5
6    2
2    2
1    1
dtype: int64

 

其一法子,更简便易行一些,然则也须要在特定的情景下去做,也是因而写的艺术。这一个点子有两个难题,

字符串方法

Series在字符串中装置了一组字符串处理办法,可以壹本万利地对数组中各类成分实行操作,如下边代码片段所示。请留意,字符串中的格局相称暗中认可使用正则表达式。(在少数意况下接二连三利用它们)。实际情况请参阅矢量字符串方法

In [71]: s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])

In [72]: s.str.lower()
Out[72]: 
0       a
1       b
2       c
3    aaba
4    baca
5     NaN
6    caba
7     dog
8     cat
dtype: object

首先个问题是:从出生到近年来停止,小编最大的悲苦是怎样?

合并

第二个难题是:那辈子,笔者最想辅助的人工胎位极度是怎么着一堆人?

连接

在三番五次/合并类型操作的情景下,Pandas提供了有个别具备用于索引和关系代数的各个函数合并Series、DataFrame和Panel对象的主意

请参阅集合1些

使用concat()把Pandas对象连接:

In [73]: df = pd.DataFrame(np.random.randn(10, 4))

In [74]: df
Out[74]: 
          0         1         2         3
0 -0.548702  1.467327 -1.015962 -0.483075
1  1.637550 -1.217659 -0.291519 -1.745505
2 -0.263952  0.991460 -0.919069  0.266046
3 -0.709661  1.669052  1.037882 -1.705775
4 -0.919854 -0.042379  1.247642 -0.009920
5  0.290213  0.495767  0.362949  1.548106
6 -1.131345 -0.089329  0.337863 -0.945867
7 -0.932132  1.956030  0.017587 -0.016692
8 -0.575247  0.254161 -1.143704  0.215897
9  1.193555 -0.077118 -0.408530 -0.862495

# break it into pieces
In [75]: pieces = [df[:3], df[3:7], df[7:]]

In [76]: pd.concat(pieces)
Out[76]: 
          0         1         2         3
0 -0.548702  1.467327 -1.015962 -0.483075
1  1.637550 -1.217659 -0.291519 -1.745505
2 -0.263952  0.991460 -0.919069  0.266046
3 -0.709661  1.669052  1.037882 -1.705775
4 -0.919854 -0.042379  1.247642 -0.009920
5  0.290213  0.495767  0.362949  1.548106
6 -1.131345 -0.089329  0.337863 -0.945867
7 -0.932132  1.956030  0.017587 -0.016692
8 -0.575247  0.254161 -1.143704  0.215897
9  1.193555 -0.077118 -0.408530 -0.862495

其多个难题是:若是我得以学会任何的才干,那么那辈子小编最想学会的技巧是怎样?

连接

SQL风格合并。请参阅数据库风格连接

In [77]: left = pd.DataFrame({'key': ['foo', 'foo'], 'lval': [1, 2]})

In [78]: right = pd.DataFrame({'key': ['foo', 'foo'], 'rval': [4, 5]})

In [79]: left
Out[79]: 
   key  lval
0  foo     1
1  foo     2

In [80]: right
Out[80]: 
   key  rval
0  foo     4
1  foo     5

In [81]: pd.merge(left, right, on='key')
Out[81]: 
   key  lval  rval
0  foo     1     4
1  foo     1     5
2  foo     2     4
3  foo     2     5

 

交给另一个例证:

In [82]: left = pd.DataFrame({'key': ['foo', 'bar'], 'lval': [1, 2]})

In [83]: right = pd.DataFrame({'key': ['foo', 'bar'], 'rval': [4, 5]})

In [84]: left
Out[84]: 
   key  lval
0  foo     1
1  bar     2

In [85]: right
Out[85]: 
   key  rval
0  foo     4
1  bar     5

In [86]: pd.merge(left, right, on='key')
Out[86]: 
   key  lval  rval
0  foo     1     4
1  bar     2     5

把那四个难点都十二分周到地应对完了以往,再串起来,就是您的重任。“你的义务,是透过第六个难题的技术,援助第2个难题里的人工产后出血,化解第3个难题中的优伤”。同样的,借使那一个确实是您的任务的话,自身都能撼动到祥和落泪,可能是一身发抖,可能是过电什么的,会有部分这么的感应。

追加

增加行到DataFrame。请参阅追加

In [87]: df = pd.DataFrame(np.random.randn(8, 4), columns=['A','B','C','D'])

In [88]: df
Out[88]: 
          A         B         C         D
0  1.346061  1.511763  1.627081 -0.990582
1 -0.441652  1.211526  0.268520  0.024580
2 -1.577585  0.396823 -0.105381 -0.532532
3  1.453749  1.208843 -0.080952 -0.264610
4 -0.727965 -0.589346  0.339969 -0.693205
5 -0.339355  0.593616  0.884345  1.591431
6  0.141809  0.220390  0.435589  0.192451
7 -0.096701  0.803351  1.715071 -0.708758

In [89]: s = df.iloc[3]

In [90]: df.append(s, ignore_index=True)
Out[90]: 
          A         B         C         D
0  1.346061  1.511763  1.627081 -0.990582
1 -0.441652  1.211526  0.268520  0.024580
2 -1.577585  0.396823 -0.105381 -0.532532
3  1.453749  1.208843 -0.080952 -0.264610
4 -0.727965 -0.589346  0.339969 -0.693205
5 -0.339355  0.593616  0.884345  1.591431
6  0.141809  0.220390  0.435589  0.192451
7 -0.096701  0.803351  1.715071 -0.708758
8  1.453749  1.208843 -0.080952 -0.264610

 

各位,那一个讲职分的宗旨就大致,方法其实极粗略,主要的是投机去达成,那接下去倘诺有怎么着想要提问的,能够咨询。

分组

“分组”大家指的是涉嫌叁个或多少个以下步骤的长河

  • Splitting:遵照局地标大校数据分组
  • Applying:将效能独立运用于各样组
  • Combining:将结果合并成数据结构

请参阅分组部分

In [91]: df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
   ....:                           'foo', 'bar', 'foo', 'foo'],
   ....:                    'B' : ['one', 'one', 'two', 'three',
   ....:                           'two', 'two', 'one', 'three'],
   ....:                    'C' : np.random.randn(8),
   ....:                    'D' : np.random.randn(8)})
   ....: 

In [92]: df
Out[92]: 
     A      B         C         D
0  foo    one -1.202872 -0.055224
1  bar    one -1.814470  2.395985
2  foo    two  1.018601  1.552825
3  bar  three -0.595447  0.166599
4  foo    two  1.395433  0.047609
5  bar    two -0.392670 -0.136473
6  foo    one  0.007207 -0.561757
7  foo  three  1.928123 -1.623033

 

分组,然后将sum()函数应用于生成的组。

In [93]: df.groupby('A').sum()
Out[93]: 
            C        D
A                     
bar -2.802588  2.42611
foo  3.146492 -0.63958

按多列分组产生层次索引,然后利用该函数。

In [94]: df.groupby(['A','B']).sum()
Out[94]: 
                  C         D
A   B                        
bar one   -1.814470  2.395985
    three -0.595447  0.166599
    two   -0.392670 -0.136473
foo one   -1.195665 -0.616981
    three  1.928123 -1.623033
    two    2.414034  1.600434

义务一旦从潜意识回升到意识层面,身心的合壹度会有光辉的火速!

重塑

请参阅有关支行索引重塑部分

In [95]: tuples = list(zip(*[['bar', 'bar', 'baz', 'baz',
   ....:                      'foo', 'foo', 'qux', 'qux'],
   ....:                     ['one', 'two', 'one', 'two',
   ....:                      'one', 'two', 'one', 'two']]))
   ....: 

In [96]: index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])

In [97]: df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A', 'B'])

In [98]: df2 = df[:4]

In [99]: df2
Out[99]: 
                     A         B
first second                    
bar   one     0.029399 -0.542108
      two     0.282696 -0.087302
baz   one    -1.575170  1.771208
      two     0.816482  1.100230

方法三:百自身物传记

stack()主意将”压缩”DataFrame列中的二个等第。

In [100]: stacked = df2.stack()

In [101]: stacked
Out[101]: 
first  second   
bar    one     A    0.029399
               B   -0.542108
       two     A    0.282696
               B   -0.087302
baz    one     A   -1.575170
               B    1.771208
       two     A    0.816482
               B    1.100230
dtype: float64

采纳”stacked”DataFrame或Series(有三个MultilIndex作为目录)stack()的反向操作是unstack(),它默许意况下解除最终二个等第。

In [102]: stacked.unstack()
Out[102]: 
                     A         B
first second                    
bar   one     0.029399 -0.542108
      two     0.282696 -0.087302
baz   one    -1.575170  1.771208
      two     0.816482  1.100230

In [103]: stacked.unstack(1)
Out[103]: 
second        one       two
first                      
bar   A  0.029399  0.282696
      B -0.542108 -0.087302
baz   A -1.575170  0.816482
      B  1.771208  1.100230

In [104]: stacked.unstack(0)
Out[104]: 
first          bar       baz
second                      
one    A  0.029399 -1.575170
       B -0.542108  1.771208
two    A  0.282696  0.816482
       B -0.087302  1.100230

翻阅100本各领域的人物传记。找到十二分心有戚戚然的活法。当你读完100本传记,你还会发觉更多东西……

数据透视表

请参阅数码透视表部分

In [105]: df = pd.DataFrame({'A' : ['one', 'one', 'two', 'three'] * 3,
   .....:                    'B' : ['A', 'B', 'C'] * 4,
   .....:                    'C' : ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] * 2,
   .....:                    'D' : np.random.randn(12),
   .....:                    'E' : np.random.randn(12)})
   .....: 

In [106]: df
Out[106]: 
        A  B    C         D         E
0     one  A  foo  1.418757 -0.179666
1     one  B  foo -1.879024  1.291836
2     two  C  foo  0.536826 -0.009614
3   three  A  bar  1.006160  0.392149
4     one  B  bar -0.029716  0.264599
5     one  C  bar -1.146178 -0.057409
6     two  A  foo  0.100900 -1.425638
7   three  B  foo -1.035018  1.024098
8     one  C  foo  0.314665 -0.106062
9     one  A  bar -0.773723  1.824375
10    two  B  bar -1.170653  0.595974
11  three  C  bar  0.648740  1.167115

咱俩得以轻松地从那个数量中高速变化数据透视表:

In [107]: pd.pivot_table(df, values='D', index=['A', 'B'], columns=['C'])
Out[107]: 
C             bar       foo
A     B                    
one   A -0.773723  1.418757
      B -0.029716 -1.879024
      C -1.146178  0.314665
three A  1.006160       NaN
      B       NaN -1.035018
      C  0.648740       NaN
two   A       NaN  0.100900
      B -1.170653       NaN
      C       NaN  0.536826

例如:

时间体系

Pandas具备简易、壮大和高效的功能,用于在变频时期试行重采样操作。那在财政和经济应用中国和欧洲平时见,但是不幸免此。请参阅日子类别部分

In [108]: rng = pd.date_range('1/1/2012', periods=100, freq='S')

In [109]: ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)

In [110]: ts.resample('5Min').sum()
Out[110]: 
2012-01-01    25083
Freq: 5T, dtype: int64

 

时区表示

In [111]: rng = pd.date_range('3/6/2012 00:00', periods=5, freq='D')

In [112]: ts = pd.Series(np.random.randn(len(rng)), rng)

In [113]: ts
Out[113]: 
2012-03-06    0.464000
2012-03-07    0.227371
2012-03-08   -0.496922
2012-03-09    0.306389
2012-03-10   -2.290613
Freq: D, dtype: float64

In [114]: ts_utc = ts.tz_localize('UTC')

In [115]: ts_utc
Out[115]: 
2012-03-06 00:00:00+00:00    0.464000
2012-03-07 00:00:00+00:00    0.227371
2012-03-08 00:00:00+00:00   -0.496922
2012-03-09 00:00:00+00:00    0.306389
2012-03-10 00:00:00+00:00   -2.290613
Freq: D, dtype: float64

退换来另权且区

In [116]: ts_utc.tz_convert('US/Eastern')
Out[116]: 
2012-03-05 19:00:00-05:00    0.464000
2012-03-06 19:00:00-05:00    0.227371
2012-03-07 19:00:00-05:00   -0.496922
2012-03-08 19:00:00-05:00    0.306389
2012-03-09 19:00:00-05:00   -2.290613
Freq: D, dtype: float64

在时间跨度之间转变

In [117]: rng = pd.date_range('1/1/2012', periods=5, freq='M')

In [118]: ts = pd.Series(np.random.randn(len(rng)), index=rng)

In [119]: ts
Out[119]: 
2012-01-31   -1.134623
2012-02-29   -1.561819
2012-03-31   -0.260838
2012-04-30    0.281957
2012-05-31    1.523962
Freq: M, dtype: float64

In [120]: ps = ts.to_period()

In [121]: ps
Out[121]: 
2012-01   -1.134623
2012-02   -1.561819
2012-03   -0.260838
2012-04    0.281957
2012-05    1.523962
Freq: M, dtype: float64

In [122]: ps.to_timestamp()
Out[122]: 
2012-01-01   -1.134623
2012-02-01   -1.561819
2012-03-01   -0.260838
2012-04-01    0.281957
2012-05-01    1.523962
Freq: MS, dtype: float64

在时刻和岁月戳之间转换,能够利用部分有利的算术函数。在底下例子中:

In [123]: prng = pd.period_range('1990Q1', '2000Q4', freq='Q-NOV')

In [124]: ts = pd.Series(np.random.randn(len(prng)), prng)

In [125]: ts.index = (prng.asfreq('M', 'e') + 1).asfreq('H', 's') + 9

In [126]: ts.head()
Out[126]: 
1990-03-01 09:00   -0.902937
1990-06-01 09:00    0.068159
1990-09-01 09:00   -0.057873
1990-12-01 09:00   -0.368204
1991-03-01 09:00   -1.144073
Freq: H, dtype: float64

《特斯拉回想录》

明确的

自0.一伍本子的话,Pandas能够在DataFrame中包涵分类数据。有关总体文书档案,请参阅分类介绍API文档

In [127]: df = pd.DataFrame({"id":[1,2,3,4,5,6], "raw_grade":['a', 'b', 'b', 'a', 'a', 'e']})

将原始数据转变为分类数据。

In [128]: df["grade"] = df["raw_grade"].astype("category")

In [129]: df["grade"]
Out[129]: 
0    a
1    b
2    b
3    a
4    a
5    e
Name: grade, dtype: category
Categories (3, object): [a, b, e]

将项目重命名叫更有意义的称谓

In [130]: df["grade"].cat.categories = ["very good", "good", "very bad"]

重新排列系列并还要增多丢失的档次(Series.cat下的秘诀再次回到贰个暗中认可的新Series)。

In [131]: df["grade"] = df["grade"].cat.set_categories(["very bad", "bad", "medium", "good", "very good"])

In [132]: df["grade"]
Out[132]: 
0    very good
1         good
2         good
3    very good
4    very good
5     very bad
Name: grade, dtype: category
Categories (5, object): [very bad, bad, medium, good, very good]

排序是按体系中的顺序排序的,而不是词法顺序。

In [133]: df.sort_values(by="grade")
Out[133]: 
   id raw_grade      grade
5   6         e   very bad
1   2         b       good
2   3         b       good
0   1         a  very good
3   4         a  very good
4   5         a  very good

按分类列分组还显得空体系。

In [134]: df.groupby("grade").size()
Out[134]: 
grade
very bad     1
bad          0
medium       0
good         2
very good    3
dtype: int64

《毛泽东传》

绘图

绘图文档

In [135]: ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))

In [136]: ts = ts.cumsum()

In [137]: ts.plot()
Out[137]: <matplotlib.axes._subplots.AxesSubplot at 0x1187d7278>

图片 1

在DataFrame中,plot()能够方便绘制带标签的全部列。

In [138]: df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index,
   .....:                   columns=['A', 'B', 'C', 'D'])
   .....: 

In [139]: df = df.cumsum()

In [140]: plt.figure(); df.plot(); plt.legend(loc='best')
Out[140]: <matplotlib.legend.Legend at 0x11b5dea20>

图片 2

《Franklin自传》

获取数据输入/输出

《林肯传》

CSV

写入多少个csv文件

In [141]: df.to_csv('foo.csv')

 

从csv文件读取

In [142]: pd.read_csv('foo.csv')
Out[142]: 
     Unnamed: 0          A          B         C          D
0    2000-01-01   0.266457  -0.399641 -0.219582   1.186860
1    2000-01-02  -1.170732  -0.345873  1.653061  -0.282953
2    2000-01-03  -1.734933   0.530468  2.060811  -0.515536
3    2000-01-04  -1.555121   1.452620  0.239859  -1.156896
4    2000-01-05   0.578117   0.511371  0.103552  -2.428202
5    2000-01-06   0.478344   0.449933 -0.741620  -1.962409
6    2000-01-07   1.235339  -0.091757 -1.543861  -1.084753
..          ...        ...        ...       ...        ...
993  2002-09-20 -10.628548  -9.153563 -7.883146  28.313940
994  2002-09-21 -10.390377  -8.727491 -6.399645  30.914107
995  2002-09-22  -8.985362  -8.485624 -4.669462  31.367740
996  2002-09-23  -9.558560  -8.781216 -4.499815  30.518439
997  2002-09-24  -9.902058  -9.340490 -4.386639  30.105593
998  2002-09-25 -10.216020  -9.480682 -3.933802  29.758560
999  2002-09-26 -11.856774 -10.671012 -3.216025  29.369368

[1000 rows x 5 columns]

 

《Jobs传》

HDF5

读写HDF存储

写入HDF5存储

In [143]: df.to_hdf('foo.h5','df')

从HDF五存款和储蓄中读取

In [144]: pd.read_hdf('foo.h5','df')
Out[144]: 
                    A          B         C          D
2000-01-01   0.266457  -0.399641 -0.219582   1.186860
2000-01-02  -1.170732  -0.345873  1.653061  -0.282953
2000-01-03  -1.734933   0.530468  2.060811  -0.515536
2000-01-04  -1.555121   1.452620  0.239859  -1.156896
2000-01-05   0.578117   0.511371  0.103552  -2.428202
2000-01-06   0.478344   0.449933 -0.741620  -1.962409
2000-01-07   1.235339  -0.091757 -1.543861  -1.084753
...               ...        ...       ...        ...
2002-09-20 -10.628548  -9.153563 -7.883146  28.313940
2002-09-21 -10.390377  -8.727491 -6.399645  30.914107
2002-09-22  -8.985362  -8.485624 -4.669462  31.367740
2002-09-23  -9.558560  -8.781216 -4.499815  30.518439
2002-09-24  -9.902058  -9.340490 -4.386639  30.105593
2002-09-25 -10.216020  -9.480682 -3.933802  29.758560
2002-09-26 -11.856774 -10.671012 -3.216025  29.369368

[1000 rows x 4 columns]

《硅谷钢铁侠:埃隆·马斯克的冒险人生》

Excel

读写Excel

写入Excel文件

In [145]: df.to_excel('foo.xlsx', sheet_name='Sheet1')

从Excel文件读取

In [146]: pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA'])
Out[146]: 
                    A          B         C          D
2000-01-01   0.266457  -0.399641 -0.219582   1.186860
2000-01-02  -1.170732  -0.345873  1.653061  -0.282953
2000-01-03  -1.734933   0.530468  2.060811  -0.515536
2000-01-04  -1.555121   1.452620  0.239859  -1.156896
2000-01-05   0.578117   0.511371  0.103552  -2.428202
2000-01-06   0.478344   0.449933 -0.741620  -1.962409
2000-01-07   1.235339  -0.091757 -1.543861  -1.084753
...               ...        ...       ...        ...
2002-09-20 -10.628548  -9.153563 -7.883146  28.313940
2002-09-21 -10.390377  -8.727491 -6.399645  30.914107
2002-09-22  -8.985362  -8.485624 -4.669462  31.367740
2002-09-23  -9.558560  -8.781216 -4.499815  30.518439
2002-09-24  -9.902058  -9.340490 -4.386639  30.105593
2002-09-25 -10.216020  -9.480682 -3.933802  29.758560
2002-09-26 -11.856774 -10.671012 -3.216025  29.369368

[1000 rows x 4 columns]

《王阳明传》

陷阱

倘使你品尝以下操作,能够观看如下格外:

>>> if pd.Series([False, True, False]):
    print("I was true")
Traceback
    ...
ValueError: The truth value of an array is ambiguous. Use a.empty, a.any() or a.all().

 

《稻盛和夫自传》

《Li Ka-shing传》

《拿破仑传》

《荣格自传》

《实验鼠Bucky》(富乐硕士自传)

《维特根Stan传》

《Chaplin自传》&《Chaplin传》

《贝多芬传》

《艾伦·图灵传》

《Newton传——最终的炼金术士》

《自由与宽容:曼德拉传》VS《漫漫自由路:曼德拉自传》

《俾斯麦传》VS《思索与纪念》

《黑泽明100》VS《蛤蟆的油》

《凡高传》VS《亲爱的提奥》

《黄永玉传》VS《比笔者老的年长者》

《Russell传》VS《罗素纪念录》

《Liang Shuming传》VS《作者生有涯愿数不尽》

《茨威格在巴西》VS《今天的社会风气》《四人民代表大相会》

《纳博科夫传》VS《说啊,回想》

《John穆勒自传》

《人生舞台:阿Simon夫自传》

《小编的努力:希特勒自传》《希特勒传:从乞讨的人到元首》

《别闹了,费曼先生》

《当人类的群星闪耀时》

《亚当·斯密传》

《凯恩斯传》

《爱因Stan传》

《富甲美利坚联邦合众国·零售大王沃尔顿自传》

《活着为了讲述生活:Garcia马尔克斯的自传》

《小编在世的种种形式》

《购并霸业:时期沃纳CEOSteve·罗丝传》

《穷Charles宝典》

《毛姆传》

《阿桑奇自传:不可能不说的机要》

《一流金融家》

《常识之败:雷曼背后的金融方面包车型客车权力角逐》

《玛丽娜·阿布拉莫维奇传》

《心灵的激情——Freud传》

《对生存的渴求——梵高传》

《马背上的海员——杰克London传》

《起点——达尔文传》

《小编要做物医学家》

《陈布雷回想录》

《 苏格拉底传》

《忏悔录》

《西塞罗传》

……

读有名气的人传记的八条理由

帮衬我们发现世界的复杂性

豆蔻年华时读传记,只看得见高大人物的远大,哪个地方看得见世界的繁杂。今后,就算是平时生活中的大家,选择焦虑、人格障碍、关系缺点和失误都让每二个见惯不惊的决策纠结十三分。设想,何况那1个身处紧张时势超越大家充裕且还要精心、谨慎、果断地作出裁决的传主呢。二十拾虚岁后,大家再细看英豪有名的人的史事,越来越多并不是为了精通其理解,而是感慨其环境之复杂,共鸣其决定之辛苦。

扶助大家识到哪个人都爱莫能助躲避的阴毒法则

豆蔻年华时读传记,只记得大侠人物铁肩担道义,哪个地方知晓背后更多是人生的扑朔迷离劳碌、尘寰运营规律的暴虐残暴和不为人知的曲折。秘Luli马共和国的布鲁图斯为了爱戴共和制度,杀了投机的多少个儿子。秘Luli马共和国末年的布鲁图斯,为了掩护共和社会制度,刺杀了恺撒,却既没能维持奥克兰共和国,也没能保住本身的生命。在此以前,大家惊讶之超越人性的宏伟;明天,我们只怕才会体会到各个背后的切肤之痛,种种猜想的辛酸凶狠。

读过不少传记后,大家才知晓,平凡的人生未尝不是万幸

妙龄时读传记,大家平时以有名的人为对象,立下宏伟誓言。但那时再读,回过头来细细品读他们的人生,就会发现不日常的人生背后,可能别有一番苦头,他们捐躯了五花八门看似平时也许普通的幸福,换取了过去留名。物军事学家、教育家帕斯Carl,他的人命高度凝练,3七周岁就耗尽了生命的能量,英年早逝。文学家斯宾诺莎也遗弃了整套世俗荣誉,在四六周岁的中年因职业病而死。政治军事人物更不知凡几。那样实在值得吗?只怕平凡的人生,未尝不是我们的侥幸。3七周岁的大家,恐怕更愿意追求大家平时生活的各样小确幸。

看看硬汉有名的人的灰暗,我们的人生本事更从容

身先士卒不是跳跃在字里行间的公事公办纸人儿,他们内心的纠结、无助、彷徨等世间清味,与大家并无二致。人性都有黯淡、复杂的一面,繁多时候,不是何等丰功伟绩那般单薄清澈。有的人既是大手笔和勇敢,也有挥之不去的恶行。有的人歌唱自由,却作出极端严酷、邪恶的事。有的人既维护正义,又尤其卑鄙。唯有经历1番人生阅历,大家才精通,世界不是二元的,英豪更不是三遍元的。

在人生的转折处,大家更亟待来自外人的平行力量

三10而立,大家具有了和睦人生的一段轨迹,能够与球星们平行比照,历史的山川、人生的转向点,他们是如何做出抉择的?豪杰们的功成名就必然与她们所处时期的本人的握住有关,跟他们对照,我们完成了怎么?还并未能如愿怎么着?他们的沉思方法有啥借鉴的含义?少年读到但无能为力付诸推行的盛名家员成长经历,近日,都足以改为帮我们做出取舍的“平行力量”。

传记是人性的试验场,我们可试探人性的顶点

名人身上的一切都以被推广的,传记作者、商量人口拿出放大镜来探究他们身上的全体,哪怕是1根毛发。多数作业普通人即使经历了,也不会被传出、进而引发人们的构思,可是有名的人的推广效应使得大家能够从中透顶地剖析人生中恐怕的考验,伟大的人选往往是性子的试验场,人性的昏暗和光辉都被发挥到了最佳,大家可以从中思虑人生的终点。同时,伟人有机遇面临老百姓毕生都没机会合对的新鲜机会,他们的裁定、考虑、行为,有时展现了性子最美好、无私、类似Smart的1端,有时又浮现了人性最残酷的一面。比如易卜生,公共层面,他是个尤其关注妇女时局的文学家;但在私人生活中,他对亲朋好友,还有之前的私生子十一分残暴。你也更无法想像,批判现实主义小说家巴尔扎克本身是何等拜金。

让大家学会心和气平地接受差异

少年时,都没做过天才铁汉梦。当认识到祥和不是天赋,只是通常人时,大家才终于第贰的成人。以后的大家读传记,越发平缓地接受大家与她们中间的差异,也可以越来越清楚地认识自个儿的不完美,并尽力在那几个不圆满的社会风气里有所为,更重视的是,有所不为。

找到属于您的“关键时刻”,达成生命的潜能,无论你有多普通

名流之所以得到成就,正是因为她在少数地方的发狂。是的,事实正是如此不可捉摸,我们为她异于常人的疯狂而倒下。那对我们一样颇具莫大的振作成效,有名的人是能清晰地认识小编的人,他们放任其余全数,一心追求本身,最后释放出超过常规的力比多,引领着大千世界前行。大家要由这个人物传记的花哨陷阱,譬如励志、成功学、幸福鸡汤,各个洗脑等等,大家要认真探究从老百姓飞速到有名的人那三个关键时刻的爆发:一定是心灵深处的自小编释放。无论我们多大多老,无论我们经历了略微波折与打击,找到并落到实处足够属于作者的“关键时刻”,恐怕,才是1个普通人读有名气的人传记最为深邃的理由。

找到人生职分的“标准”

当您找到人生职务时,你会被自己的答案,感动得潸然泪下,恐怕是壹身发抖,可能是人身过电等感到。

Leave a Comment.