python数据挖掘包Pandas基本操作

原文博客：https://zhuanlan.zhihu.com/p/25013519

---

官网： http://pandas.pydata.org/pandas-docs/stable/

Pandas安装和使用

安装方式与python安装库方式一样：pip install -U pandas （-U表示安装最新版本）
注意：要先安装numpy，因为pandas会用到此库
安装过程的问题，具体问题具体百度解决

python数据结构

一般将pandas简称为pd：import pandas as pd
一、 Series

>>> pd.Series([5,4])0    51    4dtype: int64

说明：pandas中数据类型会具体涉及到int32、int64等。默认为64位，也可自行修改。
Series可理解为一个一维数组，只是index可以自己设置
* 创建方法
创建方法统一为:pd.Series(data,index=)
Series可以通过三种形式创建：python的dict、numpy当中的ndarray（numpy中的基本数据结构）、具体某个数值。
1. dic

>>> dict_s = pd.Series({'a':1,'b':2,'d':3},index=['a','b','c','d'])>>> dict_sa     1b     2c   NaNd     3dtype: float64

说明：
- 打印的时候按照index赋值顺序
- 当某个index对应值为空就是NaN(如上index=’c’时，值为NaN)、
- 即使index被赋值之后，绝对位置不会被覆盖。
2. numpy中的ndarray

 >>> import numpy as np>>> np_s = pd.Series(np.random.randn(5),index=list('ABCDE'))>>> np_sA   -1.057819B   -0.370827C   -0.985265D    0.997723E   -0.751130dtype: float64

1. 具体某个值

>>> s = pd.Series(5)>>> s0    5dtype: int64>>> s_li = pd.Series([5,4])>>> s_li0    51    4dtype: int64>>> s_lis = pd.Series(5,index=list('abcd'))>>> s_lisa    5b    5c    5d    5dtype: int64

说明：
- 不对index进行赋值时，默认从０开始
- 某个值的创建方法，保证每行数据精准性的话很麻烦，并且用起来会不小心把其他数据覆盖掉
注意：创建Series的时候要注意创建行数和索引数量匹配的问题，如下不匹配会报错

s_li_in = pd.Series([5,4],index=list(‘abcd’))

查询
使用s.values和s.index，分别查询值和索引

>>> s_li.valuesarray([5, 4])>>> s_li.indexInt64Index([0, 1], dtype='int64')

二、DataFrame
类似表格的数据类型: DataFrame可以理解为一个二维数组，index有两个维度，可更改

参数：
- data （方框内的数据）: numpy ndarray (structured or homogeneous), dict, or DataFrame
- index（行索引索引） : Index or array-like
- columns （列索引）: Index or array-like
- dtype（data的数据类型） : dtype, default None
统一创建形式：pd.DataFrame(data,columns=,index=)
Data的创建形式: 一维数据类型进行创建、二维ndarray创建、外部输入
* 一维数据类型创建（一维ndarray、列表、字典、Series等）
1. 将字典或Series组合成列表再进行创建

 >>> dic = {'a':1,'b':2}>>> d = pd.Series([3,4,5],index=list('abc'))>>> pd.DataFrame([dic,d],columns=list('abcd'))   a  b   c   d0  1  2 NaN NaN1  3  4   5 NaN

说明：
- 字典和series组成两行，顺序是在[dic,d]设定
- data数据的具体值，对应每行具体类型的index对应值(第一行为：dic，其a列对应值为dic中a=1)
- columns值是由DataFrame内指定
2. 将两者放入字典中创建

  >>> a = {'a':1,}>>> a = {'a':1,'b':2}>>> b = pd.Series([4,5,6],index=list('abc'))>>> data = {'one':a,'two':b}>>> pd.DataFrame(data,columns=['one','two','a','b'])   one  two    a    ba    1    4  NaN  NaNb    2    5  NaN  NaNc  NaN    6  NaN  NaN[3 rows x 4 columns]

说明：
- 很明显，这种方式将不同对象按列组合创建(第一种为行)
- 结果行名：对象的index
注意：两种方法都要注意列名匹配的问题
3. 数组和列表
列表或者一维的ndarray可以通过转化为Series或者字典进行创建，或者变为对应的二维的数据类型进行处理
* 二维数组

*外部输入
读取文件等手段，如csv、excel等文件：先读取一个文件对象（pd.read_xxx，xxx是对应的文件类型，常用有csv、excel、table等)的对象，然后再通过该对象创建DataFrame，但要注意columns列名的命名。

>>> csv = pd.read_csv('/home/huiqin/Desktop/pandas.csv')# 利用pd.read_csv数据已经是:class 'pandas.core.frame.DataFrame'>>> csv_data = pd.DataFrame(csv,columns=['a','b','c'])>>> csv_data.head()   a  b  c0  1  2  31  2  3  42  3  4  53  4  5  64  5  6  7[5 rows x 3 columns]

• 三维与多维数组：Panel/PanelND

数据类型操作

一、Series操作

查看
简单来说就是通过索引查看：一种是通过index对应的标签；另一种就是通过绝对位置查看
1. 绝对位置: s[xxx] xxx:　可以是数字、列表或者表达式

 >>> s[[4,3,1]]e    5d    5b    5dtype: float64>>> s[s>1]a    5b    5c    5d    5e    5dtype: float64>>> s[0]5.0

1. 通过标签

>>> s['a']5.0>>> 'f' in sFalse>>> s.get('e')5.0>>> s.get('f',np.nan)nan

三种方式：s[‘a’]、’e’ in s、或者s.get(‘f’,np.nan)

s[‘a’]：返回标签对应数值或者NaN
　’e’ in s返回true/false
　s.get(‘f’) 返回label对应的值，如果没有读取到就无返回值，加入np.nan参数可在没有读取到时返回NaN

运算
操作运算符：　+、-、*、/、np.exp以及关系运算等运算符

>>> s-sa    0b    0c    0d    0e    0dtype: float64>>> s[1:]+s[:3]a   NaNb    10c    10d   NaNe   NaNdtype: float64

两个Series运算是其中一个Series中每个index位置和另一个Series对应index位置进行算数运算；也可以选取部分进行运算，在选取部分运算的时候要注意只能运算index相同的部分，不重合的部分则是NaN
* 命名
创建的时候使用使用name参数,可以通过name方法进行查询

>>> s = pd.Series(np.random.randn(5),name='something')>>> s.name'something'

二、DataFrame操作
* 查询
DataFrame.head可以查询前几行的数据，默认为前五行；DataFrame.tail查看后几行书，默认为5行；DataFrame.describe查看全部数据

>>> csv_data.tail()     a   b   c8    9  10  119   10  11  1210  11  12  1311  12  13  1412  13  14  15[5 rows x 3 columns]>>> csv_data.describe()              a         b         ccount  13.00000  13.00000  13.00000mean    7.00000   8.00000   9.00000std     3.89444   3.89444   3.89444min     1.00000   2.00000   3.0000025%     4.00000   5.00000   6.0000050%     7.00000   8.00000   9.0000075%    10.00000  11.00000  12.00000max    13.00000  14.00000  15.00000[8 rows x 3 columns]

排序
df.sort_index(axis=,ascending=) axis为0/1的参数，表示按行/按列排序；ascending为boolean参数，False表示降序，True表示升序。

>>> csv_data.sort_index(axis=0,ascending=False)     a   b   c12  13  14  1511  12  13  1410  11  12  139   10  11  128    9  10  117    8   9  106    7   8   95    6   7   84    5   6   73    4   5   62    3   4   51    2   3   40    1   2   3[13 rows x 3 columns]

删除
使用del或者pop(‘columns’)方法: pop由于弹出特定的列，会返回被弹出的列中的数值
注意：所有删除的方法都会改变原来DataFrame，而不是像其他方法一样内存当中新建一个DataFrame

>>> csv_data     a   b   c0    1   2   31    2   3   42    3   4   53    4   5   6[13 rows x 3 columns]>>> del csv_data['a']>>> csv_data     b   c0    2   31    3   42    4   53    5   6[13 rows x 2 columns]>>> csv_data.pop('b')0      21      32      43      5

运算
运算：+、-、*、/、exp以及关系运算等，类似于Series，两个DataFrame运算是一个DataFrame每个位置的值和对应位置另一个DataFrame的值进行运算，DataFrame转置DataFrame.T。也可选取特定的columns参与运算
注意：*不是矩阵相乘（叉乘），矩阵计算是numpy.linalg

>>> csv_data.T   0   1   2   3   4   5   6   7   8   9   10  11  12c   3   4   5   6   7   8   9  10  11  12  13  14  15[1 rows x 13 columns]>>> csv['d']=csv['b']*csv['c']>>> csv     a   b   c    d0    1   2   3    61    2   3   4   122    3   4   5   203    4   5   6   30[13 rows x 4 columns]

修改与添加
1. 修改
利用=即可实现修改功能，同时可以在=右边加上赋值的范围，赋值号同样会改变原来DataFrame当中的数值

>>> csv['a']=1>>> csv    a   b   c    d0   1   2   3    61   1   3   4   122   1   4   5   203   1   5   6   30

1. 添加
   添加新的列 ：改变DataFrame数据
   首先肯定是重新创建一个新的DataFrame；
   其二就是上述的赋值做法，给原来DataFrame当中的新列进行赋值
   其三就是通过insert(loc, column, value, allow_duplicates=False)方法进行
   通过DataFrame.assign对表格进行改动，该方法会返回改动后的DataFrame，但不是改动原来的DataFrame
   使用loc、iloc等都可以添加新列

>>> csv.insert(1,'e',csv['a'])>>> csv    a  e   b   c    d0   1  1   2   3    61   1  1   3   4   122   1  1   4   5   203   1  1   5   6   30[13 rows x 5 columns]

选择/切片
1. 直接按照行/列进行选择：　用columns选择列，用index选择行
注意：选择列的时候单次只能选择某一列的数据，不能同时选择多列；而使用index的时候一定要使用范围（类似于[1:2]），单独某个index会报错

>>> csv['a']0     11     12     13     1Name: a, dtype: int64>>> csv[:1]   a  e  b  c  d0  1  1  2  3  6[1 rows x 5 columns]

1. 使用loc方法，通过位置标签选择：ataFrame.loc[index:index,[‘columns’]]　
   注意：loc方法当中的columns可以选择多列，如果表示只按列选择的话index可以不填但是冒号（：）和逗号（，）一定要写

>>> csv.loc[:,['a','b']]    a   b0   1   21   1   32   1   43   1   5[13 rows x 2 columns]

1. loc还能这么用：DataFrame.loc[index,[‘columns’]]，这时的index为特定能够的label或值，这样用会返回一个Series。里面的index和columns都是唯一的，返回一个值。由于降维的问题，pandas会对精度进行转换

>>> ss2 = csv.loc[0,['a']]>>> type(ss2)<class 'pandas.core.series.Series'>

1. 使用iloc方法，通过绝对位置选择
   思路与loc方法基本相同，只是把标签换成绝对位置

>>> csv.iloc[[0,1],2:3]   b0  21  3[2 rows x 1 columns]

1. 用where操作通过表达式过滤部分值，并且将过滤掉的值作为NaN
2. 使用isin([value])方法:去除特定列当中与变量值相等的行，返回一个DataFrame

>>> csv[csv['b'].isin([2,3,4])]   a  e  b  c   d0  1  1  2  3   61  1  1  3  4  122  1  1  4  5  20[3 rows x 5 columns]

NaN
1. DataFrame.dropna.(axis，how) 常用参数为axis和how
axis为0/1参数；
how为any/all参数，any是存在NaN就把对应的整行/列删除，all是全部为NaN才把对应的整行/列删除

>>> csv['g']=np.NaN>>> csv    a  e   b   c    d   g0   1  1   2   3    6 NaN1   1  1   3   4   12 NaN2   1  1   4   5   20 NaN3   1  1   5   6   30 NaN>>> csv.dropna(axis=1,how='any')    a  e   b   c    d0   1  1   2   3    61   1  1   3   4   122   1  1   4   5   203   1  1   5   6   30

1. DataFrame.fillna(value) 将所有NaN赋值为value

>>> csv.isnull()        a      e      b      c      d     g0   False  False  False  False  False  True1   False  False  False  False  False  True2   False  False  False  False  False  True3   False  False  False  False  False  True

合并
合并的时候尽量保证columns是相同的，有利于后续操作
1. pd.concat([DataFrame1,···],ignore_index) 可以多个DataFrame进行合并，ignore_index是boolean值，用来确定要不要重新对index从0开始赋值。
2. pd.merge(DataFrame1,DataFrame2) DataFrame1在合并后的上面DataFrame2在合并后的下面；on是确定合并的列。同时merge会重新分配index，不会出现index重合
3. DataFrame.append(object,ignore_index) 在DataFrame尾部添加一个object，可以是DataFrame也可以是Series，ignore_index就是用来确定要不要重新对index从0开始赋值，这个比较好理解。

分组
1. 通过groupby命令实现的，主要实现的功能是按照一些规则将数据分为不同的组；对于每组数据分别执行一个函数；将结果组合到一个数据结构中。

DataFrame.groupby(by=None, axis=0, as_index=True)

参数解释：
- by是按照分组的列名
- axis是作用维度，0为行，1为列
- as_index指的是分组依据是否作为索引存在，有多个分组依据时，会合并成一个tuple，作为一列
2. aggregate(arg)方法可以打印分好组的group，arg可以为dict类型或者list类型

 >>> g = csv.groupby(['b','c'])>>> g<pandas.core.groupby.DataFrameGroupBy object at 0x7f1654a0cf50>>>> g.aggregate(np.sum)       e    d   gb  c             2  3   1    6 NaN3  4   1   12 NaN4  5   1   20 NaN>>> g = csv.groupby(['b','c'],as_index=False)>>> g.aggregate(np.sum)     b   c  e    d   g0    2   3  1    6 NaN1    3   4  1   12 NaN2    4   5  1   20 NaN3    5   6  1   30 NaN

然后可以通过agg(arg)方法对分好组的group进行计算（arg可以为dict类型或者list类型）

>>> g = csv.groupby('b')>>> g['b'].agg([np.mean])    meanb       2      23      34      45      5

时间
时间部分比较复杂，涉及到时区，时间戳，时间跨度等转换

三、Panel/PanelND
多维数组由于篇幅和内容深度的问题无法继续展开，但是基本操作的框架和前面两个相似

常用pandas操作

拆分数据框列到多列

参考博客：拆分
方法１：apply函数

df = pd.read_csv(fname, comment="#")dfs = df[df.TEST == 'READ']# function to convert the hexstring into a binary stringdef hex2bin(hstr): return bin(int(hstr,16))[2:]# convert the hexstring in column DATA to binarystring ROWDATAdfs['BINDATA'] = dfs['DATA'].apply(hex2bin)# get rid of the column DATAdel dfs['DATA']

方法２：简单字符操作

for i in range(16):     dfs['B'+str(i)] = dfs['BINDATA'].str[i]

方法3: 不是很懂

import pandas as pd# read the above frame from the clipboarddf = pd.read_clipboard(converters={'BINDATA': str})df = df.fillna(nan).replace('None', nan).dropna(axis=0, how='all')# here are the lines that matterbindata = df.BINDATA.apply(list).apply(Series)bindata.columns = bindata.columns.map('B{0}'.format)res = pd.concat([df, bindata], axis=1).convert_objects(convert_numeric=True)

四、其他博客
很多实例:http://www.cnblogs.com/chaosimple/p/4153083.html
常用操作：http://python.jobbole.com/85742/　
数据分析：http://www.cnblogs.com/nxld/p/6058591.html