pythonpandas教程(pythonpandas读取excel文件)

pandas所包含的数据结构和数据处理工具的设计使得在Python中进行数据清理和分析非常快捷。pandas经常是和其他数值计算工具，例如Numpy和SciPy，以及数据可视化工具matplotlib一起使用。pandas支持大部分Numpy语言风格的数组计算，尤其是数组函数及没有for循环的各种数据处理。

Numpy适合于处理同质型的数值类数组数据。pandas是用来处理表格型或异质型数据的。

使用import pandas as pd 导入pandas包

series是一种一维的数组型对象，包含了一个值序列，并包含了数据标签，即索引index。最简单的序列可以仅仅由一个数组形成

import pandas as pd
obj=pd.Series([4,7,1,3])

obj
0    4
1    7
2    1
3    3
dtype: int64

一般情况下，Series的字符串表示，索引在左边，值在右边。索引默认生成从0到N-1（N为数据的长度）。可以通过value属性和index属性分别获取Series对象的值和索引

当需要创建一个索引序列而不是使用默认生成的索引时，可使用以下方式

import pandas as pd
obj=pd.Series([4,7,1,3],index=['a','b','c','d'])

obj
a    4
b    7
c    1
d    3
dtype: int64

与Numpy数组相比，Series数组可以从数据中选择数据的时候使用标签来进行索引

eg：obj['a']

Series可以认为是一个长度固定且有序的字典，因为其索引值和数据值是按位置配对的。如果已经有数据包含在字典中，可使用Series将字典生成为Series。

sdata={'a':1,'b':2,'c':3,'d':4}
s=pd.Series(sdata)

当需要将自带你传递给Series构造函数时，产生的Series的索引将时排序好的字典键。可以将字典键按照任意需要的顺序传递给构造函数，从而使生成的Series索引顺序符合需要：

states=['first','second','third','forth']
s1=pd.Series(sdata,index=states)

s1
first    NaN
second   NaN
third    NaN
forth    NaN
dtype: float64
出现NaN的原因是这四个索引没有出现在state的键中，所以对应的值为NaN，这是pandas标记缺失值的方式。

pandas使用isnull和notnull函数来检查缺失的数据：

pd.isnull(s1)
first     True
second    True
third     True
forth     True
dtype: bool

Series的对象自身和其索引都有name属性，这个特性与pandas其他重要功能集成在一起

s1.name='sort'
s1.index.name='state'

s1
state
a    1
b    2
c    3
d    4
Name: sort, dtype: int64

Series的索引可以通过按位赋值的方式进行改变

s1.index=['first','second','third','forth']

s1
first     1
second    2
third     3
forth     4
dtype: int64

Dataframe是表示矩阵的数据表，包含了已排序的列集合，每一列都可以是不同的值类型。Dataframe既有行索引，也有列索引，可以被视为一个共享相同索引的Series的字典。在Dataframe中，数据被存储在一个以上的二位快，而不是列表、字典或其他以为数组的集合。尽管Dataframe是二维的，但也可以用分层索引在Dataframe中展现更高维度的数据。分层索引是pandas中一种更为高级的数据处理特性。

有多种方式可以构建Dataframe，最常用的方式是利用包含等长度列表或Numpy数组的字典来形成Dataframe，产生的索引由Series自动分配，并且列会按照排序的顺序排列：

data={'state':['a','b','c','d','e'],
      'year':['2000','2001','2002','2003','2004'],
      'pop':[1,2,3,4,5]}
frame=pd.Dataframe(data)

frame
  state  year  pop
0     a  2000    1
1     b  2001    2
2     c  2002    3
3     d  2003    4
4     e  2004    5

当制定了列的顺序，Dataframe的列将会按照指定顺序排列

data2=pd.Dataframe(data,columns=['year','state','pop'])

data2
   year state  pop
0  2000     a    1
1  2001     b    2
2  2002     c    3
3  2003     d    4
4  2004     e    5

如果传入的列不包含在字典中，将会在结果中出现缺失值

frame2=pd.Dataframe(data,columns=['year','state','pop','debt'],index=['one','two','three','four','five'])

frame2
         year state  pop debt
one    2000     a    1  NaN
two    2001     b    2  NaN
three  2002     c    3  NaN
four   2003     d    4  NaN
five   2004     e    5  NaN

Dataframe中的一列，可以按字典类型标记或属性那样检索为Series，frame2[column]

frame2['state']
one      a
two      b
three    c
four     d
five     e
Name: state, dtype: object

frame2.year
one      2000
two      2001
three    2002
four     2003
five     2004
Name: year, dtype: object

行可以通过位置或特殊属性loc进行选取，即frame2.loc[]

frame2.loc['one']
year     2000
state       a
pop         1
debt      NaN
Name: one, dtype: object
列的引用时可以修改的，比如空的‘debt’列可以赋值为标量值或值数组

frame2['debt']=11
frame2
       year state  pop  debt
one    2000     a    1    11
two    2001     b    2    11
three  2002     c    3    11
four   2003     d    4    11
five   2004     e    5    11

frame2['debt']=np.arange(5)
frame2
       year state  pop  debt
one    2000     a    1     0
two    2001     b    2     1
three  2002     c    3     2
four   2003     d    4     3
five   2004     e    5     4
当将列表或数组赋值给一个列时，值得长度必须和Dataframe得长度匹配。如果将Series赋值给一列时，Series得索引将会按照Dataframe得索引重新排序，并在缺失得地方填充缺失值

val=pd.Series([43,23,12],index=['one','two','four'])
frame2['debt']=val

frame2
       year state  pop  debt
one    2000     a    1  43.0
two    2001     b    2  23.0
three  2002     c    3   NaN
four   2003     d    4  12.0
five   2004     e    5   NaN
如果被赋值得列不存在，则会生成一个新得列，del关键字可以对Dataframe中删除列

frame2['eastern']=frame2.state=='a'

frame2
       year state  pop  debt  eastern
one    2000     a    1  43.0     True
two    2001     b    2  23.0    False
three  2002     c    3   NaN    False
four   2003     d    4  12.0    False
five   2004     e    5   NaN    False
 

del frame2['eastern']

frame2
       year state  pop  debt
one    2000     a    1  43.0
two    2001     b    2  23.0
three  2002     c    3   NaN
four   2003     d    4  12.0
five   2004     e    5   NaN
从Dataframe中选择得列时数据的视图，而不是拷贝，因此对Series得修改会被映射到Dataframe中。如果需要复制，则可以显式得使用Series得copy方法。

也可以使用数据烈性为包含字典得嵌套字典，如果嵌套字典被赋值给Dataframe，pandas会将字典得键作为列，将内部字典得键作为行索引

data={'state':{'2000':1,'2001':2,'2002':3,'2003':4,'2004':5},
      'year':{'2000':1.2,'2001':1.3,'2002':1.4,'2003':1.5,'2004':1.6}}
frame=pd.Dataframe(data)

frame
      state  year
2000      1   1.2
2001      2   1.3
2002      3   1.4
2003      4   1.5
2004      5   1.6
可以对Dataframe进行转置操作

frame.T

       2000  2001  2002  2003  2004
state   1.0   2.0   3.0   4.0   5.0
year    1.2   1.3   1.4   1.5   1.6
含有Series得字典也可以用于构造Dataframe

pdata={'ohio':frame['state'][:1],
       'Nevada':frame['year'][:2]}
frame1=pd.Dataframe(pdata)

frame1
      ohio  Nevada
2000   1.0     1.2
2001   NaN     1.3

可以使用values属性将包含在Dataframe中得数据以二维ndarray得形式返回

frame1.values
array([[1. , 1.2],
       [nan, 1.3]])

一些索引对象的方法和属性

reindex时pandas对象的重要方法，该方法用于创建一个符合新索引的新对象，。Series调用reindex方法时，会将数据按照新的索引进行排序，如果某个索引值之前不存在，则会引入缺失值。

obj=pd.Series([4,5,6,7],index=['d','b','a','c'])
obj1=obj.reindex(['a','b','c','d'])

obj
d    4
b    5
a    6
c    7
dtype: int64
obj1
a    6
b    5
c    7
d    4
dtype: int64
对于顺序数据，例如时间序列，在重建索引时可能会需要进行插值或填值。method可以选参数允许使用注入ffill等方法在重建索引时插值，ffill方法会将值前向填充

obj2=pd.Series(['bliue','purple','yellow'],index=[0,2,4])

obj2
0     bliue
2    purple
4    yellow
dtype: object

obj2.reindex(range(6),method='ffill')
0     bliue
1     bliue
2    purple
3    purple
4    yellow
5    yellow
dtype: object
在Dataframe中，reindex可以改变行索引、列索引，也可以同时改变二者。当仅传入一个序列时，结果中的行会重建索引

frame=pd.Dataframe(np.arange(9).reshape((3,3)),
                   index=['a','c','d'],
                   columns=['ohio','texas','california'])

states=['texas','utah','california']
frame.reindex(columns=states)
   texas  utah  california
a      1   NaN           2
c      4   NaN           5
d      7   NaN           8
也可以使用loc进行更为简洁的标签索引。

当已经拥有索引数组或不含条目的列表，在轴向上删除一个或多个条目就非常容易，但这样需要一些数据操作和集合逻辑，drop方法会返回一个含有指示值或轴向上删除值的新对象

frame=pd.Dataframe(np.arange(5),
                   index=['a','b','c','d','e'])

frame
   0
a  0
b  1
c  2
d  3
e  4

new_frame=frame.drop('c')
new_frame
   0
a  0
b  1
d  3
e  4
在Dataframe中，索引值可以从轴向上删除，在使用drop函数时，可根据行或列进行删除；

frame.drop(),axis默认为行，当设置axis=0或者axis=‘columns'时，可定义按列删除

Series的索引与Numpy数组索引的功能类似，只不过Series的索引值可以不仅仅为整数

obj=pd.Series(np.arange(4.),index=['a','b','c','d'])

obj
a    0.0
b    1.0
c    2.0
d    3.0
dtype: float64
obj[1]
1.0
obj['b']
1.0

针对Dataframe在行上的标签索引，有两个特殊的索引符号loc和iloc，它们允许使用轴标签（loc）或整数标签（iloc）以Numpy风格的语法从Dataframe中选择出数组的行和列的子集。

不同索引的对象之间的算术行为时pandas提供给一些应用的一项重要特征，当使对象相加时，如果存在某个索引对不相同，则返回结果得索引将时索引对的并集。就相当于数据库的自动外连接。

s1=pd.Series([7.3,-2.5,3.4,1.5],index=['a','b','c','d'])
s2=pd.Series([-2.1,3.6,-1.5,4,3.1],index=['a','c','e','f','g'])
s3=s1+s2

s1
a    7.3
b   -2.5
c    3.4
d    1.5
dtype: float64
s2
a   -2.1
c    3.6
e   -1.5
f    4.0
g    3.1
dtype: float64
s3
a    5.2
b    NaN
c    7.0
d    NaN
e    NaN
f    NaN

没有交叠的标签位置上，内部数据对齐会产生缺失值。缺失值会在后续的算术操作上产生影响。

因此，在两个不同的索引化对象之间进行算术操作时，假设当轴标签在一个对象中存在，在另一个对象中不存在，当使用0来填补缺失值时：

df1=pd.Dataframe(np.arange(12.).reshape((3,4)),columns=list('abcd'))
df2=pd.Dataframe(np.arange(20.).reshape((4,5)),columns=list('abcde'))
df2.loc[1,'b']=np.nan

df1
     a    b     c     d
0  0.0  1.0   2.0   3.0
1  4.0  5.0   6.0   7.0
2  8.0  9.0  10.0  11.0
df2
      a     b     c     d     e
0   0.0   1.0   2.0   3.0   4.0
1   5.0   NaN   7.0   8.0   9.0
2  10.0  11.0  12.0  13.0  14.0
3  15.0  16.0  17.0  18.0  19.0

在df1上使用add发给发，经df2与fill_value作为参数传入：
df1.add(df2,fill_value=0)
      a     b     c     d     e
0   0.0   2.0   4.0   6.0   4.0
1   9.0   5.0  13.0  15.0   9.0
2  18.0  20.0  22.0  24.0  14.0
3  15.0  16.0  17.0  18.0  19.0