分分钟搞定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。。。
扫一扫
1039
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
