padas 学习笔记

本文是关于pandas的学习笔记，由于pandas会用到numpy，可能需要读者简单了解一下numpy的内容，不过有用到的部分我会在文中进行简单解释说明。

资料来源主要是两块，一是pandas: powerful Python data analysis toolkit；另一个《利用python进行数据分析》（Wes McKinney）

目录

一、pandas的安装和使用

二、python数据结构

三、对数据类型的操作

四、总结

一、pandas的安装和使用

Pandas和其他python的库安装方式一样，whl、源码或者pip，在此就不赘述了，Python Data Analysis Library 上面有github源码和whl文件。

注意：pandas安装会用到numpy库，因此在安装pandas之前一定要安装好numpy。

Pandas安装的时候还有两个大坑：如果如果是VC++ is required，说明要装Visual Studio，这个百度Visual Studio安装即可；如果是excention is required，比如我碰到的CExcention，说明需要安装对应的拓展包，这个情况可以通过Python Extension Packages for Windows 这个网站下载。由于欧皇血统，安装过程不算崎岖，希望踩到其他坑的小伙伴可以多留言让我们整理一下碰到的问题。

Pandas在使用的时候一般会和numpy一起使用，并且官方给pandas简称pd，numpy简称np，原因我就不知道了。

二、python数据结构

说明：pandas当中数据类型会具体涉及到int32、int64等等，没有进行设置的时候pandas默认输出64位，如果考虑内存使用效率的话可以自行修改。

1、Series

Series可以理解为一个一维的数组，只是index可以自己改动。

创建的方法统一为pd.Series(data,index=)。打印的时候按照index赋值的顺序，有的时候会看着很别扭。某个index对应的值为空就用NaN。

index参数默认从0开始的整数，也是Series的绝对位置，即使index被赋值之后，绝对位置不会被覆盖。

Series可以通过三种形式创建：python的dict、numpy当中的ndarray（numpy中的基本数据结构）、具体某个数值。index赋值必须是list类型。

Python的dict创建：

s = pd.Series({‘a’=1,’b’=2,’d’=3},index = [‘a’,’d’,’c’,b’])
输出：a  1	
      d  3
      c  NaN
      b  2
      dtype：int64

numpy中的ndarray：

s = pd.Series(np.random.randn(5), index = list('ABCDE')
输出：A   -1.130657
     B   -1.539251
     C    1.503126
     D    1.266908
     E    0.335561
     dtype: float64 

具体某个值：

s=pd.Series(5)
输出：0    5	
dtype: int64	
s=pd.Series([5,4]) 
输出：0	5   
     1	4 
dtype: int64
s=pd.Series([5,4],index=list[‘abcd’])
输出：ERROR	
S=pd.Series(5,index=list(‘abcd’))
a	5
b	5
c	5
d       5
dtype:int64

像这种具体某个值的创建方法，保证每行数据精准性的话很麻烦，并且用起来会不小心把其他数据覆盖掉，因此我个人用的比较少。

注意：创建Series的时候要注意创建行数和索引数量匹配的问题，如果默认的话会自动匹配创建的行数。

除了创建肯定需要查询，这时候会用到s.values和s.index，分别查询值和索引。

2、DataFrame

DataFrame是一个类似于表格的数据类型，如图：

有这样一些参数： data  （方框内的数据）: numpy ndarray (structured or homogeneous), dict, or DataFrame

index（行索引索引） : Index or array-like

columns （列索引）: Index or array-like

dtype（data的数据类型） : dtype, default None

DataFrame可以理解为一个二维数组，index有两个维度，可更改。

DataFrame统一的创建形式为：pd.DataFrame(data,columns=,index=)其中columns为列的索引，index为行的索引。index或者columns如果不进行设置则默认为0开始的整数，也是行的绝对位置，不会被覆盖；而通过外部数据（比如打开文件）创建DataFrame的话需要注意列名匹配的问题，给columns赋的值如果和数据来源当中列名不一样的话，对应的列下面会出现NAN。还有个常用参数为orient，默认为空，如果赋值’index’则将输入Series的index值作为DataFrame的columns。栗子如下：

a = pd.read_csv('c:/users/15418/Desktop/bajiao.csv')
pd.DataFrame(a,columns = ['a','b','commentsNum'])
输出：a   b  commentsNum
0  NaN NaN         9795
1  NaN NaN        21088
2  NaN NaN         4107
3  NaN NaN         4115
4  NaN NaN        39300

Data的创建形式有以下几种：一维数据类型进行创建、二维ndarray创建、外部输入。

二维数组创建，由于比较简单就先说：pd.DataFrame(二维数组,columns = ,index=)，由于比较简单就不举代码了。

外部输入就是读取文件等手段，如csv、excel等文件：上面那个例子已经说明了读取文件创建过程。概括来说就是先读取一个文件对象（pd.read_xxx，xxx是对应的文件类型，常用有csv、excel、table等)的对象，然后再通过该对象创建DataFrame，但要注意columns列名的命名。

一维数据类型创建（一维数据类型主要有：一维ndarray、列表、字典、Series等）：

首先是字典和Series类型创建DataFrame：一个是将字典或者Series组合成列表进行创建；另一个是将两者放入字典里面创建。例子如下：

第一种方法：

a = {'a':1,'b':2}
b = pd.Series([1,2,3],index=list('abc'))
pd.DataFrame([a,b],columns = list('abcd'))
输出：a  b    c   d
  0  1  2  NaN  NaN
  1  1  2  3.0   NaN

第二种方法：

a = {'a':1,'b':2}
b = pd.Series([1,2,3],index=list('abc'))
data = {'one':a,'two':b}
pd.DataFrame(data,columns = ['one','two','a','d'])
输出：one  two    a    d
  a  1.0    1  NaN  NaN
  b  2.0    2  NaN  NaN
  c  NaN    3  NaN  NaN

这两种方法都要注意列名匹配的问题。

然后是数组和列表类型的创建：列表或者一维的ndarray可以通过转化为Series（见1、Series）或者字典进行创建，或者变为对应的二维的数据类型进行处理，在此不佳赘述了。

强烈给个建议：在创建之前最好把data变量先写好然后放到DataFrame方法里面，包括对原始数据的改动也最好写在data里面。

类似于Series，DataFrame.index,DataFrame.columns可以查询DataFrame二维参数的数值。

3、Panel/PanelND

Panel可以理解为三维数组，panelND可以理解为N维数组。

高维的数组就是在三维的基础上加入更多维度参数，基本方法相同，具体差异在此就不深入展开，这里以三维为例介绍。

统一的创建方法就是pd.Panel(data,items=,major_axis=,minor_axis=)，三个维度就分别是items、major_axis、minor_axis，还有个常用参数就是orient后面会提到。

跟DataFrame类似的，三维参数如果不进行设置则默认为0开始的整数，也是行的绝对位置，不会被覆盖；如果希望把输入的DataFrame的columns作为panel的items就需要吧orient赋值为’minor’。

在创建panel的时候一般会采用两种形式（和DataFrame类似，照搬就行）：采用字典；使用items参数创建

具体举例如下：

字典：data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
              'Item2' : pd.DataFrame(np.random.randn(4, 2))}
pd.Panel(data)
输出：<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2

这里面的键就是对应items参数，当然panel这个没办法通过表的形式打印。

Items参数：df = pd.DataFrame({'a': ['foo', 'bar', 'baz'],
                             'b':np.random.randn(3)})
data = {'item1': df, 'item2': df}
pd.Panel.from_dict(data, orient='minor')
输出：<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 3 (major_axis) x 2 (minor_axis)
Items axis: a to b
Major_axis axis: 0 to 2
Minor_axis axis: item1 to item2

三、对数据类型的操作

1、对Series操作

查看：简单来说就是通过索引查看：一种是通过index对应的标签；另一种就是通过绝对位置查看。

举个例子：

s = pd.Series(5., index=['a', 'b', 'c', 'd', 'e'])

如果通过绝对位置查看，会使用s[XXX]，XXX可以是绝对位置的数字，列表，或者表达式等

s[0]
输出：5.0	

s[[4,3,1]]	
输出：e    5.0	
     d    5.0
     b    5.0
     dtype: float64
	
s[s>1]
输出：a    5.0
     b    5.0
     c    5.0
     d    5.0
     e    5.0
     dtype: float64

如果通过标签查询的话可以使用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。

s[‘a’]
输出：5.0

‘f’ in s
输出：false		

s.get(‘e’)		
输出：5.0

s.get(‘f’,np.nan)
输出：nan								

运算：常见操作运算符，+、-、*、/、np.exp以及关系运算等运算符，两个Series运算是其中一个Series中每个index位置和另一个Series对应index位置进行算数运算；也可以选取部分进行运算，在选取部分运算的时候要注意只能运算index相同的部分，不重合的部分则是NaN。

s-s				
a    0.0			
b    0.0			
c    0.0			
d    0.0			
e    0.0			
s[1:]+s[:3]
a     NaN
b    10.0
c    10.0
d     NaN
e     NaN

命名：创建的时候使用使用name参数；使用rename方法。可以通过name方法进行查询。

s = pd.Series(np.random.randn(5), name='something')
s.name
输出：'something'
s2 = s.rename("different")
s2.name
输出：'different'

2、对DataFrame操作

查询：DataFrame.head可以查询前几行的数据，默认为前五行；DataFrame.tail查看后几行书，默认为5行；DataFrame.describe查看全部数据。

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

df.sort_value(by=，ascending=) by表示按哪一个columns参数排序。

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

df = pd.DataFrame.from_items([('A', [1, 2, 3]), ('B',[4,5,6])],orient='index', columns=['one', 'two', 'three']) #后面用到的df都是从这边开始一直往下走的
del df['two']
df.pop('one')
输出：	A    1
        B    4
        Name: one, dtype: int64
df
输出：   three
   A      3
   B      6

运算：+、-、*、/、exp以及关系运算等，类似于Series，两个DataFrame运算是一个DataFrame每个位置的值和对应位置另一个DataFrame的值进行运算，因此这里的*不是矩阵相乘（叉乘）；在处理矩阵的时候会用到numpy.linalg函数（用来处理矩阵相关运算的函数），在此不赘述。另外转置的方法为DataFrame.T。

同时除了可以整个Data'frame参与运算以外还可以选取特定的columns参与运算，例如

df['three'] = df['one'] * df['two']

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

df['fore'] = 1	
df	
输出：one  two  three  fore	
  A    1    2      3     1	
  B    4    5      6     1
			
df['five'] = df['one'][:1]
df								
输出：one  two  three  fore  five   				 
  A    1    2      3     1   1.0
  B    4    5      6     1   NaN

同样的需要注意，控制赋值范围时当心其余范围的NaN处理。

添加新的列 首先肯定是重新创建一个新的DataFrame；其二就是上述的赋值做法，给原来DataFrame当中的新列进行赋值，如上面df[‘five’]的例子；其三就是通过insert(loc, column, value, allow_duplicates=False)方法进行，insert同样会改变DataFrame数据，例如：

df.insert(1, 'bar', df['one'])
df
输出： one   bar		two  three  fore five
   A    1    1		2      3     1	1.0
   B    4    4		5      6     1	NaN

另外可以通过DataFrame.assign对表格进行改动，该方法会返回改动后的DataFrame，但不是改动原来的DataFrame

df.assign(ration = df['one'] / df['one'])
输出：one  two  three  fore  five  ration
A    1    2      3     1   1.0     1.0
B    4    5      6     1   NaN     1.0

df
输出：one  two  three  fore  five
A    1    2      3     1   1.0
B    4    5      6     1   NaN

当然使用loc、iloc等都可以添加新列，这个就不赘述了。

选择/切片：

直接按照行/列进行选择：

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

df['one']>2
输出：A    False	
     B     True	
     Name: one, dtype: bool	
	
df['two']
输出：A    2						
     B    5	
     Name: two, dtype: int64

df[:1]
输出：one  bar  two  three  fore  five
A    1    1    2      3     1   1.0

使用loc方法，通过位置标签选择：

统一格式为DataFrame.loc[index:index,[‘columns’]]，loc方法当中的columns可以选择多列，如果表示只按列选择的话index可以不填但是冒号（：）和逗号（，）一定要写，例如：

df.loc[:,['two','one']]	
输出：two  one	 
A    2    1		
B    5    4

df.loc['A':'B',['one','two']]			   
输出：one  two
A    1    2		
B    4    5

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

df.loc['A',['one']]	
输出：one    1.0	
     Name: A, dtype: float64	
		
df.loc['A','one']			
输出：1.0

使用iloc方法，通过绝对位置选择：

思路与loc方法基本相同，只是把标签换成绝对位置。简答举个例子：

df.iloc[[0,1],2:3]
输出：two
A    2
B    5

使用where操作通过表达式过滤部分值，并且将过滤掉的值作为NaN，不过即使用了where操作还是需要跟上其他操作，个人实际使用不多。

df[df>3]
输出：one  bar  two  three  fore  five
  A  NaN  NaN  NaN    NaN   NaN   NaN
  B  4.0  4.0  5.0    6.0   NaN   NaN

使用isin([value])方法：

通过isin方法可以去除特定列当中与变量值相等的行，返回一个DataFrame。举个例子，

df[df['one'].isin([1])]
输出：one  bar  two  three  fore  five
A    1    1    2      3     1   1

对于NaN的处理：

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

df.dropna(axis = 1, how ='any')
输出：one  bar  two  three  fore
A    1    1    2      3     1
B    4    4    5      6     1

DataFrame.fillna(value) 将所有NaN赋值为value，比较简单就不举例了

DataFrame.isnull() 判断DataFrame是否为null，返回是boolean 的DataFrame，也比较好理解

合并：

在做合并的时候尽量保证columns是相同的，有利于后续操作

pd.concat([DataFrame1,···],ignore_index) 可以多个DataFrame进行合并，ignore_index是boolean值，用来确定要不要重新对index从0开始赋值。

pd.merge(DataFrame1,DataFrame2) DataFrame1在合并后的上面DataFrame2在合并后的下面；on是确定合并的列。同时merge会重新分配index，不会出现index重合。merge是个大坑，合并完一定是个乱七八糟的，后面一定要跟上一系列选择剔除的操作才能好好用。而且merge参数较多，情况复杂，之后的分享当中会继续深挖。

DataFrame.append(object,ignore_index) 在DataFrame尾部添加一个object，可以是DataFrame也可以是Series，ignore_index就是用来确定要不要重新对index从0开始赋值，这个比较好理解。

分组：

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

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

by是按照分组的列名；axis是作用维度，0为行，1为列；as_index指的是分组依据是否作为索引存在，有多个分组依据时，会合并成一个tuple，作为一列。

通过aggregate(arg)方法可以打印分好组的group，arg可以为dict类型或者list类型。

df2
输出：A      B         C         D
0  foo    one      1         1
1  bar    one      1         1
2  foo    two      1         1
3  bar  three      1         1
4  foo    two      1         1
5  bar    two      1         1
6  foo    one      1         1
7  foo  three      1         1

g = df2.groupby(['A','B'])
g.aggregate(np.sum)
输出：      C  D
A   B
bar one    1  1
    three  1  1
    two    1  1
foo one    2  2
    three  1  1
    two    2  2

g = df.groupby(['A','B'],as_index=False)
g.aggregate(np.sum)
输出：A      B  C  D
0  bar    one  1  1
1  bar  three  1  1
2  bar    two  1  1
3  foo    one  2  2
4  foo  three  1  1
5  foo    two  2  2

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

g = df.groupby('A')
g['D'].agg([np.mean])
输出：mean
A
bar     1
foo     1
>>>

时间：

时间部分比较复杂，涉及到时区，时间戳，时间跨度等转换，希望下次有机会在做分享。

3.Panel/PanelND

多维数组由于篇幅和内容深度的问题无法继续展开，但是基本操作的框架和前面两个相似，相信大家查阅本文的参考资料可以自己解决，这里就不详谈了。

总结

pandas是一个框架比较清晰，操作没那么复杂但是很实用的东西，笔记是我的一些学习心得，努力把自己学到的框架压缩进行分享，希望大家可以实际找点数据进行分析一下。本文参考资料当中的书和官网doc内容相当丰富，在碰到问题的时候也可以查阅。