分分钟搞定pandas (cookbook)

http://pandas.pydata.org/pandas-docs/stable/cookbook.html#cookbook
http://www.cnblogs.com/chaosimple/p/4153083.html

用python做数据分析4|pandas库介绍之DataFrame基本操作
http://www.jianshu.com/p/682c24aef525

用Python Pandas处理亿级数据
http://python.jobbole.com/84118/

Pandas透视表（pivot_table）详解
http://python.jobbole.com/81212/

>>> 
from pandas import Series,DataFrame
import pandas as pd
import numpy as np
>>> df = pd.read_excel("salesdata.xlsx")

地    区    冰棍    菜
山东    烟台    5    5
山东    青岛    367    348
山东    威海    11    11
山东    济南    360    350
山东    潍坊    297    288
北京    烟台    192    191
北京    青岛    4    4
北京    威海    3680    3512
北京    济南    100    96
上海    烟台    45    45
上海    青岛    17    17
上海    威海    104    91
上海    济南    628    581
上海    潍坊    216    194

>>> df.head(2)
    地   区   冰棍    菜
0  山东  烟台    5    5
1  山东  青岛  367  348

>>> df.index
RangeIndex(start=0, stop=14, step=1)
索引默认是数据。

>>> df.columns
Index(['地', '区', '冰棍', '菜'], dtype='object')

>>> df.values
array([['山东', '烟台', 5, 5],
       ['山东', '青岛', 367, 348],  ....
              
>>> df.describe()
              冰棍           菜
count    14.000000    14.000000   -- 14行数据. == len(df.values)
mean    430.428571   409.500000   -- 平均值   
std     952.822989   909.128048   -- std 样本标准偏差 相当于excel中STDEV，样本差的平方和除以n-3再开根号。
min       4.000000     4.000000    
25%      24.000000    24.000000
50%     148.000000   143.500000
75%     344.250000   333.000000
max    3680.000000  3512.000000

为方便起见，我们将上表中“Status”列定义为category，并按我们想要的查看方式设置顺序。(没明白)

df["状态"] = df["状态"].astype("category")
df["状态"].cat.set_categories(["won","pending","presented","declined"],inplace=True)

最简单的透视表必须有一个数据帧和一个索引。在本例中，我们将使用“区”列作为我们的索引。

pd.pivot_table(df,index=["区"])  
或者直接用df调用也行：df.pivot_table...

冰棍            菜
区 
威海  1265.000000  1204.666667
济南   362.666667   342.333333
潍坊   256.500000   241.000000
烟台    80.666667    80.333333
青岛   129.333333   123.000000
默认区是平均值（）

也可以有多个索引。实际上，大多数的pivot_table参数可以通过列表获取多个值
pd.pivot_table(df,index=["区","地"])

冰棍     菜
区    地
威海 上海   104    91
     北京  3680  3512
     山东    11    11
济南 上海   628   581
     北京   100    96
     山东   360   350
潍坊 上海   216   194
     山东   297   288
烟台 上海    45    45
     北京   192   191
     山东     5     5
青岛 上海    17    17
     北京     4     4
     山东   367   348
     
     
pd.pivot_table(df,index=["地","区"])

通过利用“values”域显式地定义我们关心的列，就可以实现移除那些不关心的列。
pd.pivot_table(df,index=["区"],values=["冰棍"])

列会自动计算数据的平均值，但是我们也可以对该列元素进行计数或求和。要添加这些功能，使用aggfunc和np.sum就很容易实现。

pd.pivot_table(df,index=["区"],values=["冰棍"],aggfunc=np.sum)
或者直接用df调用也行：
df.pivot_table(index=["区"],values=["冰棍"],aggfunc=np.sum)

pd.pivot_table(df,index=["Manager","Rep"],values=["Price"],aggfunc=np.sum)
pd.pivot_table(df,index=["经理","销售"],values=["价格"],aggfunc=np.sum)

aggfunc可以包含很多函数，,aggfunc=[np.mean,len])
>> x = df.pivot_table(index=["区"],values=["冰棍"],aggfunc=[np.mean,len,np.sum])
>>> x
           mean len   sum
             冰棍  冰棍    冰棍
区
威海  1265.000000   3  3795
济南   362.666667   3  1088
潍坊   256.500000   2   513
烟台    80.666667   3   242
青岛   129.333333   3   388

>>> x.axes
[
Index(['威海', '济南', '潍坊', '烟台', '青岛'], dtype='object', name='区'), 
MultiIndex(levels=[['mean', 'len', 'sum'], ['冰棍']], labels=[[0, 1, 2], [0, 0, 0]])
]

>>> df.axes
[
RangeIndex(start=0, stop=14, step=1), 
Index(['地', '区', '冰棍', '菜'], dtype='object')
]

列vs.值 columns
pivot_table中一个令人困惑的地方是“columns（列）”和“values（值）”的使用。
记住，变量“columns（列）”是可选的，它提供一种额外的方法来分割你所关心的实际值。
然而，聚合函数aggfunc最后是被应用到了变量“values”中你所列举的项目上。

>> x = df.pivot_table(index=["地"],values=["冰棍"],aggfunc=[np.sum])
>>> x
     sum
      冰棍
地
上海  1010
北京  3976
山东  1040

x = df.pivot_table(index=["地"],values=["冰棍"],columns=["区"],aggfunc=[np.sum])

sum
        冰棍
区     威海   济南   潍坊    烟台   青岛
地
上海   104.0  628.0  216.0   45.0   17.0
北京  3680.0  100.0    NaN  192.0    4.0
山东    11.0  360.0  297.0    5.0  367.0

--注意column和分组统计的形式不同：列表的多维度的比较，更好一些。
x = df.pivot_table(index=["地","区"],values=["冰棍"],aggfunc=[np.sum])
>>> x
            sum
            冰棍
地    区
上海 威海   104
     济南   628
     潍坊   216
     烟台    45
     青岛    17
北京 威海  3680
     济南   100
     烟台   192
     青岛     4
山东 威海    11
     济南   360
     潍坊   297
     烟台     5
     青岛   367

非数值（NaN）有点令人分心。如果想移除它们，我们可以使用“fill_value”将其设置为0。margins添加总计。
x = df.pivot_table(index=["地","区"],values=["冰棍"],aggfunc=[np.sum],fill_value=0,margins=True)

一个很方便的特性是，为了对你选择的不同值执行不同的函数，你可以向aggfunc传递一个字典。不过，这样做有一个副作用，那就是必须将标签做的更加简洁才行。
x = df.pivot_table(index=["地","区"],values=["冰棍","菜"],aggfunc={"菜":[np.sum,np.mean], "冰棍":np.mean})

>>> x.query('地==["上海"]')
          冰棍    菜
          mean mean  sum
地    区
上海 威海  104   91   91
     济南  628  581  581
     潍坊  216  194  194
     烟台   45   45   45
     青岛   17   17   17

x.plot();
     
>>> import matplotlib.pyplot as plt
>>> plt.show()

//汉字没法显示的问题。

pip install seaborn

import matplotlib as mpl
mpl.rcParams['font.sans-serif'] = ['SimHei']
mpl.rcParams['font.serif'] = ['SimHei']
import seaborn as sns
sns.set_style("darkgrid",{"font.sans-serif":['simhei', 'Arial']})

df.groupby(['NO','TIME','SVID']).count() # 分组
fullData = pd.merge(df, trancodeData)[['NO','SVID','TIME','CLASS','TYPE']] # 连接
actions = fullData.pivot_table('SVID', columns='TYPE', aggfunc='count') # 透视表

pip install wheel

之后pip install 包名字.whl 即可安装某模块包

http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy
mkl , 先numpy，再那个seaborn

帐号    姓名    销售    经理    产品    数量    价格

df.pivot_table(index=["","销售"],values=[""],columns=["产品"],aggfunc=[np.sum])

pd.pivot_table(df,index=["",""],values=["价格"],aggfunc=[np.sum],fill_value=0,margins=True)

pd.pivot_table(df,index=["经理","状态"],columns=["产品"],values=["数量","价格"],aggfunc={"数量":len,"价格":np.sum},fill_value=0)

https://my.oschina.net/lionets/blog/277847

from pandas import Series,DataFrame
import pandas as pd

2.入门

1）读取csv文件
data =pandas.read_csv(‘test.csv’) //返回的是DataFrame变量
first_rows = data.head(n) //返回前n条数据,默认返回5条
cols = data.columns //返回全部列名
dimensison = data.shape //返回数据的格式，数组，（行数，列数）
data.values //返回底层的numpy数据

2）pandas的主要数据类型dtype：
object, 字符串类型
int, 整型
float, 浮点型
datetime, 时间类型
bool, 布尔型
print data.dtpyes输出每一列的数据类型

3）索引

4）选择数据
data.loc[1] //返回单列数据
data.loc[1:3] //返回切片列数据，相当于 data.loc[[1,2,3]]
data.loc[:,['ID’]]
data.loc[:4,['ID','YELP’]] //返回指定行的指定类，从0行到4行，包括第4行

data.iloc[:,:] //返回所有数据
data.iloc[:2,1:3] //返回特定行特定列的数据

data[‘ID’] //返回列
data[2:5] //返回行
data[3:6][:2]
data[‘ID’][3:6]
data[3:6][‘ID’]

data[data.YELP>0] //YELP这列的值不为空，即NaN
data[data['ID'].isin(['v4','v5'])] //返回有这个值的列

5）缺失值处理
去掉包含缺失值的行：df.dropna(how=‘any’)
对缺失值进行填充：df.fillna(values=‘NULL’)
对数据进行布尔补充：pandas.isnull(df)

6）数据处理
<class 'pandas.core.series.Series'>
方法
to_string
to_json
json.loads(df.loc[0:5,['ID','YELP']].to_json())

>>> s = Series([1,2,3.0,'abc'])
>>> s
0      1
1      2
2      3
3    abc
dtype: object

// data最好用纯type，int，速度会快。

Series 对象包含两个主要的属性：index 和 values，分别为上例中左右两列。因为传给构造器的是一个列表，所以 index 的值是从 0 起递增的整数，如果传入的是一个类字典的键值对结构，就会生成 index-value 对应的 Series；或者在初始化的时候以关键字参数显式指定一个 index 对象：

>>> s = Series(data=[1,3,5,7],index = ['a','b','x','y'])
>>> s
a    1
b    3
x    5
y    7
dtype: int64
>>> s.index
Index(['a', 'b', 'x', 'y'], dtype='object')
>>> s.values
array([1, 3, 5, 7], dtype=int64)

Series 对象的元素会严格依照给出的 index 构建，这意味着：如果 data 参数是有键值对的，那么只有 index 中含有的键会被使用；以及如果 data 中缺少响应的键，即使给出 NaN 值，这个键也会被添加。

注意 Series 的 index 和 values 的元素之间虽然存在对应关系，但这与字典的映射不同。index 和 values 实际仍为互相独立的 ndarray 数组，

另外，Series 对象和它的 index 都含有一个 name 属性：

lang:python
>>> s.name = 'a_series'
>>> s.index.name = 'the_index'
>>> s
the_index
a            1
b            3
x            5
y            7
Name: a_series, dtype: int64

DataFrame

DataFrame 是一个表格型的数据结构，它含有一组有序的列（类似于 index），每列可以是不同的值类型（不像 ndarray 只能有一个 dtype）。基本上可以把 DataFrame 看成是共享同一个 index 的 Series 的集合。

DataFrame 的构造方法与 Series 类似，只不过可以同时接受多条一维数据源，每一条都会成为单独的一列：

>>> data = {'state':['Ohino','Ohino','Ohino','Nevada','Nevada'],
        'year':[2000,2001,2002,2001,2002],
        'pop':[1.5,1.7,3.6,2.4,2.9]}
>>> df = DataFrame(data)
>>> df
   pop   state  year
0  1.5   Ohino  2000
1  1.7   Ohino  2001
2  3.6   Ohino  2002
3  2.4  Nevada  2001
4  2.9  Nevada  2002

[5 rows x 3 columns]

较完整的 DataFrame 构造器参数为：DataFrame(data=None,index=None,coloumns=None)，columns 即 “name”：

>>> df = DataFrame(data,index=['one','two','three','four','five'],
               columns=['year','state','pop','debt'])
>>> df
       year   state  pop debt
one    2000   Ohino  1.5  NaN
two    2001   Ohino  1.7  NaN
three  2002   Ohino  3.6  NaN
four   2001  Nevada  2.4  NaN
five   2002  Nevada  2.9  NaN

[5 rows x 4 columns]

>>> df.index
Index(['one', 'two', 'three', 'four', 'five'], dtype='object')
>>> df.columns
Index(['year', 'state', 'pop', 'debt'], dtype='object')
>>> type(df['debt'])
<class 'pandas.core.series.Series'>

查找索引

查找某个值在数组中的索引，类似于 Python 内建的 list.index(value) 方法。可以通过布尔索引来实现。比如我们想在一个 Series 中寻找到 ‘c’：

lang:python
>>> ser = Series(list('abcdefg'))
>>> ser[ser='c']
2    c
dtype: object

Series 中还有一对 ser.idxmax() 和 ser.idxmin() 方法，可以返回数组中最大（小）值的索引值，或者 .argmin() 和 .argmax() 返回索引位置。当然这两类方法也是可以通过上面这种 ser[ser=ser.max()] 来替代实现的。 <br />

数组的 index 属性时不可变的，因此所谓修改索引，其实操作的是一个使用了新索引的新数组，并继承旧数据。

obj.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False) 方法接受一个新索引（key）并返回一个新数组。这个 key 的值可以是序列类型，也可以是调用者的一个列名，即将某一列设为新数组的索引。

lang:python
>>> indexed_df = df.set_index(['A', 'B'])
>>> indexed_df2 = df.set_index(['A', [0, 1, 2, 0, 1, 2]])
>>> indexed_df3 = df.set_index('column1')
<br />

重新索引

Series 对象的重新索引通过其 .reindex(index=None,**kwargs) 方法实现。**kwargs 中常用的参数有俩：method=None,fill_value=np.NaN：

lang:python
ser = Series([4.5,7.2,-5.3,3.6],index=['d','b','a','c'])
>>> a = ['a','b','c','d','e']
>>> ser.reindex(a)
a   -5.3
b    7.2
c    3.6
d    4.5
e    NaN
dtype: float64
>>> ser.reindex(a,fill_value=0)
a   -5.3
b    7.2
c    3.6
d    4.5
e    0.0
dtype: float64
>>> ser.reindex(a,method='ffill')
a   -5.3
b    7.2
c    3.6
d    4.5
e    4.5
dtype: float64
>>> ser.reindex(a,fill_value=0,method='ffill')
a   -5.3
b    7.2
c    3.6
d    4.5
e    4.5
dtype: float64
.reindex() 方法会返回一个新对象，其 index 严格遵循给出的参数，method:{'backfill', 'bfill', 'pad', 'ffill', None} 参数用于指定插值（填充）方式，当没有给出时，自动用 fill_value 填充，默认为 NaN（ffill = pad，bfill = back fill，分别指插值时向前还是向后取值）

DataFrame 对象的重新索引方法为：.reindex(index=None,columns=None,**kwargs)。仅比 Series 多了一个可选的 columns 参数，用于给列索引。用法与上例类似，只不过插值方法 method 参数只能应用于行，即轴 0。

lang:python
>>> state = ['Texas','Utha','California']
>>> df.reindex(columns=state,method='ffill')
       Texas  Utha  California
a      1   NaN           2
c      4   NaN           5    
d      7   NaN           8

[3 rows x 3 columns]
>>> df.reindex(index=['a','b','c','d'],columns=state,method='ffill')
   Texas  Utha  California
a      1   NaN           2
b      1   NaN           2
c      4   NaN           5
d      7   NaN           8

[4 rows x 3 columns]
不过 fill_value 依然对有效。聪明的小伙伴可能已经想到了，可不可以通过 df.T.reindex(index,method='**').T 这样的方式来实现在列上的插值呢，答案是可行的。另外要注意，使用 reindex(index,method='**') 的时候，index 必须是单调的，否则就会引发一个 ValueError: Must be monotonic for forward fill，比如上例中的最后一次调用，如果使用 index=['a','b','d','c'] 的话就不行。 <br />

删除指定轴上的项

即删除 Series 的元素或 DataFrame 的某一行（列）的意思，通过对象的 .drop(labels, axis=0) 方法：

lang:python
>>> ser
d    4.5
b    7.2
a   -5.3
c    3.6
dtype: float64
>>> df
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8

[3 rows x 3 columns]
>>> ser.drop('c')
d    4.5
b    7.2
a   -5.3
dtype: float64
>>> df.drop('a')
   Ohio  Texas  California
c     3      4           5
d     6      7           8

[2 rows x 3 columns]
>>> df.drop(['Ohio','Texas'],axis=1)
   California
a           2
c           5
d           8

[3 rows x 1 columns]
.drop() 返回的是一个新对象，元对象不会被改变。 <br />

索引和切片

就像 Numpy，pandas 也支持通过 obj[::] 的方式进行索引和切片，以及通过布尔型数组进行过滤。

不过须要注意，因为 pandas 对象的 index 不限于整数，所以当使用非整数作为切片索引时，它是末端包含的。

lang:python
>>> foo
a    4.5
b    7.2
c   -5.3
d    3.6
dtype: float64
>>> bar
0    4.5
1    7.2
2   -5.3
3    3.6
dtype: float64
>>> foo[:2]
a    4.5
b    7.2
dtype: float64
>>> bar[:2]
0    4.5
1    7.2
dtype: float64
>>> foo[:'c']
a    4.5
b    7.2
c   -5.3
dtype: float64
这里 foo 和 bar 只有 index 不同——bar 的 index 是整数序列。可见当使用整数索引切片时，结果与 Python 列表或 Numpy 的默认状况相同；换成 'c' 这样的字符串索引时，结果就包含了这个边界元素。

另外一个特别之处在于 DataFrame 对象的索引方式，因为他有两个轴向（双重索引）。

可以这么理解：DataFrame 对象的标准切片语法为：.ix[::,::]。ix 对象可以接受两套切片，分别为行（axis=0）和列（axis=1）的方向：

lang:python
>>> df
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8

[3 rows x 3 columns]
>>> df.ix[:2,:2]
   Ohio  Texas
a     0      1
c     3      4

[2 rows x 2 columns]
>>> df.ix['a','Ohio']
0
而不使用 ix ，直接切的情况就特殊了：

索引时，选取的是列
切片时，选取的是行
这看起来有点不合逻辑，但作者解释说 “这种语法设定来源于实践”，我们信他。

lang:python
>>> df['Ohio']
a    0
c    3
d    6
Name: Ohio, dtype: int32
>>> df[:'c']
   Ohio  Texas  California
a     0      1           2
c     3      4           5

[2 rows x 3 columns]
>>> df[:2]
   Ohio  Texas  California
a     0      1           2
c     3      4           5

[2 rows x 3 columns]
还有一种特殊情况是：假如有这样一个索引 index([2,4,5]) ，当我们使用 ser[2] 索引的时候，到底会被解释为第一个索引还是第三个索引呢？

答案是第一个索引，即当你的数组 index 是整数类型的时候，你使用整数索引，都会被自动解释为基于标签的索引，而不是基于位置的索引。要想消除这种歧义，可以使用

.loc[label] 这是严格基于标签的索引
.iloc[inte] 这是严格基于整数位置的索引
.ix[] 更像是这两种严格方式的智能整合版。

使用布尔型数组的情况，注意行与列的不同切法（列切法的 : 不能省）：

lang:python
>>> df['Texas']>=4
a    False
c     True
d     True
Name: Texas, dtype: bool
>>> df[df['Texas']>=4]
   Ohio  Texas  California
c     3      4           5
d     6      7           8

[2 rows x 3 columns]
>>> df.ix[:,df.ix['c']>=4]
   Texas  California
a      1           2
c      4           5
d      7           8

[3 rows x 2 columns]
<br />

算术运算和数据对齐

pandas 最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，结果的索引取索引对的并集。自动的数据对齐在不重叠的索引处引入空值，默认为 NaN。

lang:python
>>> foo = Series({'a':1,'b':2})
>>> foo
a    1
b    2
dtype: int64
>>> bar = Series({'b':3,'d':4})
>>> bar
b    3
d    4
dtype: int64
>>> foo + bar
a   NaN
b     5
d   NaN
dtype: float64
DataFrame 的对齐操作会同时发生在行和列上。

当不希望在运算结果中出现 NA 值时，可以使用前面 reindex 中提到过 fill_value 参数，不过为了传递这个参数，就需要使用对象的方法，而不是操作符：df1.add(df2,fill_value=0)。其他算术方法还有：sub(), div(), mul()。

Series 和 DataFrame 之间的算术运算涉及广播，暂时先不讲。 <br />

函数应用和映射

Numpy 的 ufuncs（元素级数组方法）也可用于操作 pandas 对象。

当希望将函数应用到 DataFrame 对象的某一行或列时，可以使用 .apply(func, axis=0, args=(), **kwds) 方法。

lang:python
f = lambda x:x.max()-x.min()
>>> df
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8

[3 rows x 3 columns]
>>> df.apply(f)
Ohio          6
Texas         6
California    6
dtype: int64
>>> df.apply(f,axis=1)
a    2
c    2
d    2
dtype: int64
<br />

排序和排名

Series 的 sort_index(ascending=True) 方法可以对 index 进行排序操作，ascending 参数用于控制升序或降序，默认为升序。

若要按值对 Series 进行排序，当使用 .order(na_last=True, ascending=True, kind='mergesort') 方法，任何缺失值默认都会被放到 Series 的末尾。

在 DataFrame 上，.sort_index(axis=0, by=None, ascending=True) 方法多了一个轴向的选择参数与一个 by 参数，by 参数的作用是针对某一（些）列进行排序（不能对行使用 by 参数）：

lang:python
>>> df.sort_index(by='Ohio')
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8

[3 rows x 3 columns]
>>> df.sort_index(by=['California','Texas'])
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8

[3 rows x 3 columns]
>>> df.sort_index(axis=1)
   California  Ohio  Texas
a           2     0      1
c           5     3      4
d           8     6      7

[3 rows x 3 columns]
排名（Series.rank(method='average', ascending=True)）的作用与排序的不同之处在于，他会把对象的 values 替换成名次（从 1 到 n）。这时唯一的问题在于如何处理平级项，方法里的 method 参数就是起这个作用的，他有四个值可选：average, min, max, first。

lang:python
>>> ser=Series([3,2,0,3],index=list('abcd'))
>>> ser
a    3
b    2
c    0
d    3
dtype: int64
>>> ser.rank()
a    3.5
b    2.0
c    1.0
d    3.5
dtype: float64
>>> ser.rank(method='min')
a    3
b    2
c    1
d    3
dtype: float64
>>> ser.rank(method='max')
a    4
b    2
c    1
d    4
dtype: float64
>>> ser.rank(method='first')
a    3
b    2
c    1
d    4
dtype: float64
注意在 ser[0]=ser[3] 这对平级项上，不同 method 参数表现出的不同名次。

DataFrame 的 .rank(axis=0, method='average', ascending=True) 方法多了个 axis 参数，可选择按行或列分别进行排名，暂时好像没有针对全部元素的排名方法。 <br />

统计方法

pandas 对象有一些统计方法。它们大部分都属于约简和汇总统计，用于从 Series 中提取单个值，或从 DataFrame 的行或列中提取一个 Series。

比如 DataFrame.mean(axis=0,skipna=True) 方法，当数据集中存在 NA 值时，这些值会被简单跳过，除非整个切片（行或列）全是 NA，如果不想这样，则可以通过 skipna=False 来禁用此功能：

pip install xlrd
pip install xlwt

from pandas import Series,DataFrame
import pandas as pd
data = pd.read_excel('Ax.xls','Sheet1')
data3 = pd.read_excel('B.xls','A')

data=pd.read_excel(catering_data,sheetname=0,index_col=u'日期')

data=pd.read_excel('Ax.xls',sheetname=0,index_col=u'姓名')

dx=pd.read_excel('Ax.xls',sheetname=0)

x = dx.groupby(['职业（工种）名称','鉴定级别']).count()

total_actions = x.pivot_table('身份证号码', index=['职业（工种）名称', '鉴定级别'], columns='身份证号码', aggfunc='count')

x.pivot_table(index=["鉴定级别"])

为此，“Account”和“Quantity”列对于我们来说并没什么用。所以，通过利用“values”域显式地定义我们关心的列，就可以实现移除那些不关心的列。

pd.pivot_table(df,index=["Manager","Rep"],values=["Price"])

“Price”列会自动计算数据的平均值，但是我们也可以对该列元素进行计数或求和。要添加这些功能，使用aggfunc和np.sum就很容易实现。
import numpy as np
pd.pivot_table(df,index=["Manager","Rep"],values=["Price"],aggfunc=np.sum)

---------- contact 合并数组。

df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
         'B': ['B0', 'B1', 'B2', 'B3'],
                 'C': ['C0', 'C1', 'C2', 'C3'],
                  'D': ['D0', 'D1', 'D2', 'D3']},
                   index=[0, 1, 2, 3])

df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                 'B': ['B4', 'B5', 'B6', 'B7'],
                 'C': ['C4', 'C5', 'C6', 'C7'],
                   'D': ['D4', 'D5', 'D6', 'D7']},
                  index=[4, 5, 6, 7])

df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
                  'B': ['B8', 'B9', 'B10', 'B11'],
                   'C': ['C8', 'C9', 'C10', 'C11'],
                  'D': ['D8', 'D9', 'D10', 'D11']},
                  index=[8, 9, 10, 11])

frames = [df1, df2, df3]
result = pd.concat(frames)

total_actions.plot(subplots=False, figsize=(18,6), kind='area')

total_actions = fullData.pivot_table('SVID', index='TIME', columns='TYPE', aggfunc='count')
total_actions.plot(subplots=False, figsize=(18,6), kind='area')

>>> dx.index
RangeIndex(start=0, stop=46917, step=1)

>>> dx.columns
Index(['身份证号码', '姓名', '职业（工种）名称', '鉴定级别', '理论成绩', '实操成
绩', '外语成绩', '综合成绩', '评定成绩', '证书编号', '颁证日期', '鉴定科目', '鉴定机构名称', '计划名称'],
dtype='object')
      
dx.values      
>>> dx.values[0]
array(['370622196811030097', '张绪东', '白酒酿造工', '一级', 75.0, 82.0, nan, 80.0,'合格', 1615060000100018.0, '2016-12-31', '理论实操综合', '蓬莱市职业技能鉴定中心','烟台2016高级技师评审'], dtype=object)

dx.describe()

>>> dx.describe()
          理论成绩     实操成绩  外语成绩   综合成绩   证书编号
count  44895.000000  44297.000000   0.0  1010.000000  3.246300e+04
mean      64.089313     69.204325   NaN    64.618812  1.643514e+15
std       17.231968     16.562277   NaN    22.609413  4.512077e+13
min        0.000000      0.000000   NaN     0.000000  1.615000e+15
25%       60.000000     64.200000   NaN    62.000000  1.615060e+15
50%       66.000000     72.000000   NaN    75.000000  1.615063e+15
75%       75.000000     79.000000   NaN    76.000000  1.715060e+15
max      100.000000    100.000000   NaN    88.000000  1.715063e+15
>>> type(dx.describe())
<class 'pandas.core.frame.DataFrame'>

tx.T 转置矩阵.

使用 DataFrame.dtypes 可以查看每列的数据类型，Pandas默认可以读出int和float64，其它的都处理为object，需要转换格式的一般为日期时间。DataFrame.astype() 方法可对整个DataFrame或某一列进行数据格式转换，支持Python和NumPy的数据类型。

df['Name'] = df['Name'].astype(np.datetime64)

df.groupby(['NO','TIME','SVID']).count() # 分组

fullData = pd.merge(df, trancodeData)[['NO','SVID','TIME','CLASS','TYPE']] # 连接

actions = fullData.pivot_table('SVID', columns='TYPE', aggfunc='count') # 透视表

total_actions = fullData.pivot_table('SVID', index='TIME', columns='TYPE', aggfunc='count')
total_actions.plot(subplots=False, figsize=(18,6), kind='area')

tranData = fullData[fullData['Type'] == 'Transaction']

import pandas as pd
reader = pd.read_csv('data/servicelogs', iterator=True)
try:
    df = reader.get_chunk(100000000)
except StopIteration:
    print "Iteration is stopped."

Pandas的非空计算速度很快，9800万数据也只需要28.7秒。得到初步信息之后，可以对表中空列进行移除操作。尝试了按列名依次计算获取非空列，和 DataFrame.dropna() 两种方式，时间分别为367.0秒和345.3秒，但检查时发现 dropna() 之后所有的行都没有了，查了Pandas手册，原来不加参数的情况下， dropna() 会移除所有包含空值的行。如果只想移除全部为空值的列，需要加上 axis 和 how 两个参数：

dx.groupby(['职业（工种）名称','鉴定级别']).count() # 分组

excel 操作。
http://blog.csdn.net/stepleave/article/details/51959798

注意，第一行导入的是标题。。。。第2行才算数据0。。。