文档章节

学习python的pandas学习笔记记录

east77
 east77
发布于 2017/08/18 19:53
字数 5457
阅读 28
收藏 0

分分钟搞定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。。。


 

© 著作权归作者所有

共有 人打赏支持
east77
粉丝 0
博文 8
码字总数 10359
作品 0
烟台
入门数据分析,从python开始

Python是目前学习数据分析课程中,非常重要的一块,也是目前非常受行业欢迎的。因此,学习非常重要,下面是Python学习的一些重要步骤和知识! 步骤1:熟悉Python 对数据科学,Python和R都是不...

weixin_41852491
05/28
0
0
Pandas学习记录-Series

系列()是能够保存任何类型的数据(整数,字符串,浮点数,Python对象等)的一维标记数组。轴标签统称为索引。 pandas.Series Pandas系列可以使用以下构造函数创建 - 构造函数的参数如下 - 编号...

kipeng300
09/20
0
0
Python 数据科学速查表 - Numpy、Pandas、Matplotlib 及 Jupyter Notebook

欢迎关注天善智能,我们是专注于商业智能BI,人工智能AI,大数据分析与挖掘领域的垂直社区,学习,问答、求职一站式搞定! 对商业智能BI、大数据分析挖掘、机器学习,python,R等数据领域感兴...

天善智能
09/19
0
0
七步教你Python进行机器学习

网络上有很多Python学习资源和机器学习学习资源,对于一个新手而言,如何开始呢?本篇文章将教你七步学会使用Python进行机器学习。 万事开头难。面对纷繁万千的网络学习资源,不知如何下手,...

断桥残雪断桥残雪
2015/11/20
0
0
荐书丨确认过眼神,这份Python书单一定是你的菜

点击上方“程序人生”,选择“置顶公众号” 第一时间关注程序猿(媛)身边的故事 Python 是军刀型的开源工具,被广泛应用于Web 开发、爬虫、数据清洗、自然语言处理、机器学习和人工智能等方...

csdnsevenn
05/05
0
0

没有更多内容

加载失败,请刷新页面

加载更多

arcgis jsapi接口入门系列:总览

开发环境: arcgis jsapi版本4.9 由于我们这套代码是基于vue,webpack开发的,会有少数vue代码,但总体不影响 里面还有些我们公司的js库和html css,给出的代码不能百分百直接运行,主要还是...

canneljls
19分钟前
1
0
月薪80k阿里架构师漫谈他是如何从一名小码农走到架构师的

01 刚当程序员时,我是属于那种勤勤恳恳类型的员工,工作态度用认真来形容不为过,每天我几乎是团队里最早到公司,又最晚下班的一个。而组员张工一般情况下都是准时上下班的,即使项目进度比...

Java填坑之路
21分钟前
1
0
oracle的resetlogs机制浅析

oracle的resetlogs机制浅析 alter database open resetlogs 这个命令我想大家都很熟悉了,那有没有想过这个resetlogs选项为什么要用?什么时候用? 它的原理机制是什么?他都起哪些作用? 我...

突突突酱
23分钟前
1
0
JAVA 获取两个日期间的所有日期

public static List<String> getDates(String startDate, String endDate){ List<String> dates = new ArrayList<>(); try { SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd"); Dat......

尘叙缘
29分钟前
2
0
Innodb中的事务隔离级别和锁的关系

#一次封锁or两段锁? 因为有大量的并发访问,为了预防死锁,一般应用中推荐使用一次封锁法,就是在方法的开始阶段,已经预先知道会用到哪些数据,然后全部锁住,在方法运行之后,再全部解锁。...

Skqing
43分钟前
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部