1：pandas简介
Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。
2：Series和DataFrame（）
1：Series:是一种类似于一维数组的对象，由下面两个部分组成：
Values:一组数据值（ndarray）类型
Index：相关的数据索引标签、
2：Series的创建方法
（1）由列表和numpy数组创建
>>> s=Series([1,3,4,5])
>>> s
0 1
1 3
2 4
3 5
dtype: int64
>>> #会自动将索引打印出来
>>> s.index=list('abcd')
>>> s
a 1
b 3
c 4
d 5
dtype: int64
>>> #使索引变成了字母abcd
>>> s = Series([1,2,3,4],index=['mike','sana','luna','la'])
>>> s
mike 1
sana 2
luna 3
la 4
dtype: int64
>>> #Series里面的数据是一维的
（2）由字典创建
>>> #Series里面的数据是一维的
>>> s1=Series({'a':1,'b':2})
>>> s1
a 1
b 2
dtype: int64
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
3：Series的索引
（1）显示索引
>>> s=Series(np.random.random(10),index=list('abcdefghig'))
>>> s
a 0.370897
b 0.993346
c 0.148304
d 0.456316
e 0.365877
f 0.424124
g 0.685219
h 0.694954
i 0.563674
g 0.982072
dtype: float64
>>> s['a']#使用index作为索引值
0.37089735452082695
>>> s.loc['a']#使用,loc方法显示获取索引
0.37089735452082695
>>> s[0]
0.37089735452082695
>>> s.loc[0]#因为是显示索引会报错
Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
s.loc[0]#因为是显示索引会报错
>>> s.iloc[0]
0.37089735452082695
>>> #因为此时是隐式索引所以不会报错，，隐式索引默认为0,1，2.......
>>> s.loc['a':'e']
a 0.370897
b 0.993346
c 0.148304
d 0.456316
e 0.365877
dtype: float64
>>> #切片处理
>>>
Series的基本概念
可以把Series看成一个定长的有序字典
可以通过shape，size，index，values,,等得到series的属性
>>> s.shape
(10L,)
>>> s.size
10
>>> s.index
Index([u'a', u'b', u'c', u'd', u'e', u'f', u'g', u'h', u'i', u'g'], dtype='object')
>>> s.values
array([0.37089735, 0.99334641, 0.14830394, 0.45631575, 0.36587742,
0.42412389, 0.68521869, 0.69495357, 0.56367448, 0.98207233])
>>> #Series，values，就是一个ndrray包含关系，升级的关系，有了索引更方便
>>> s.shape
(10L,)
>>> s.head
<bound method Series.head of a 0.370897
b 0.993346
c 0.148304
d 0.456316
e 0.365877
f 0.424124
g 0.685219
h 0.694954
i 0.563674
g 0.982072
dtype: float64>
>>> s.tail
<bound method Series.tail of a 0.370897
b 0.993346
c 0.148304
d 0.456316
e 0.365877
f 0.424124
g 0.685219
h 0.694954
i 0.563674
g 0.982072
dtype: float64>
>>> #Series对象本身实例有一个name属性
>>> s.name="列名"
>>> s
a 0.370897
b 0.993346
c 0.148304
d 0.456316
e 0.365877
f 0.424124
g 0.685219
h 0.694954
i 0.563674
g 0.982072
Name: ????, dtype: float64
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、’
4：Series的运算
>>> s.add(10,fill_value=0)#在进行算数运算时，如果包含nan ，那么fill_value默认设置为fill_value值
a 10.370897
b 10.993346
c 10.148304
d 10.456316
e 10.365877
f 10.424124
g 10.685219
h 10.694954
i 10.563674
g 10.982072
Name: ????, dtype: float64
>>> #Series之间的运算
>>> s1=Series([2,4,7,9],index=[0,1,2,3])
>>> s2=Series([1,2,3,4],index=[2,3,4,5])
>>> s1+s2#Series索引值，进行相加时，就是索引值进行相加
0 NaN
1 NaN
2 8.0
3 11.0
4 NaN
5 NaN
dtype: float64
>>> #要保留所有的index，必须使用.add()函数
>>> s1.add(s2,fill_value=0)
0 2.0
1 4.0
2 8.0
3 11.0
4 3.0
5 4.0
dtype: float64
>>> s1.add(s2)
0 NaN
1 NaN
2 8.0
3 11.0
4 NaN
5 NaN
dtype: float64
>>> #因为不同的Series存在不同的索引值，所以当对应另一个Series不存在该索引时要把fill_value定义为0
>>> s=Series([1,2,None])
>>> nd=np.array([1,2,None])
>>> s.sum()
3.0
>>> nd.sum()#会报错，因为有非数字，没办法进行计算
Traceback (most recent call last):
File "<pyshell#89>", line 1, in <module>
nd.sum()#会报错，因为有非数字
File "E:\Python\lib\site-packages\numpy\core\_methods.py", line 32, in _sum
return umr_sum(a, axis, dtype, out, keepdims)
TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'
>>> #ndarray中如果有nan,没有办法进行计算，而Series可以
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
5：DataFrame的定义
DataFrame是一个【表格型】的数据结构，可以看做是【由Series组成的字典】公用一个索引。DataFrame由按一定顺序排列的多列数据。设计初衷是将Series的使用场景从一维扩展到多维，DataFrame既有行索引，也有列索引
行索引：index
列索引：column
值：values（numpy的二维数组）
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
6：DataFrame的创建：
最常用的方法是由一个字典来创建，DataFrame以字典的建作为每一{列}的名称。以字典的值作为每一列
此外，dataframe和Series一样会自动为每一行加索引，相应值为nan
>>> df= DataFrame({'height':[175,180,169,188],'age':np.random.randint(18,25,size=4),'sex':['boy','girl','boy','girl']})
>>> df
age height sex
0 22 175 boy
1 20 180 girl
2 22 169 boy
3 20 188 girl
>>> df= DataFrame({'height':[175,180,169,188],'age':np.random.randint(18,25,size=4),'sex':['boy','girl','boy','girl']},index=list('ABCD'),columns=['height','age','sex','weight'])
>>> df
height age sex weight #weight默认为nan
A 175 19 boy NaN
B 180 23 girl NaN
C 169 21 boy NaN
D 188 18 girl NaN
>>> df.shape
(4, 4)
>>> df.values
array([[175L, 19, 'boy', nan],
[180L, 23, 'girl', nan],
[169L, 21, 'boy', nan],
[188L, 18, 'girl', nan]], dtype=object)
>>> df.columns
Index([u'height', u'age', u'sex', u'weight'], dtype='object')
>>> df.index
Index([u'A', u'B', u'C', u'D'], dtype='object')
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
7：DataFrame的索引
（1）对列进行索引
。通过类似字典的方式
。通过属性的方式
>>> df['age']
A 19
B 23
C 21
D 18
Name: age, dtype: int32
>>> #检索列返回值是Series
>>>
>>> df.age
A 19
B 23
C 21
D 18
Name: age, dtype: int32
>>> #对于DataFrame,列名，就相当于属性，
>>> #DataFrame是统计数据时，用的表格，某一个事物属性，每个属性对应Dataframe列名
>>> df['A']#该方法无法检索行，会报错
>>> #使用.loc[]加index来进行索引
>>> #使用.ix[]来进行索引，（过时）
>>> #使用iloc[]加整数来进行索引
>>> #对于行进行索引，返回值也是Series
>>> df.loc[['A','B']]
height age sex weight
A 175 19 boy NaN
B 180 23 girl NaN
>>> #!!!['A','B'],如果检索多行，返回的数据就是DataFrame
>>> df.loc['A':'C']
height age sex weight
A 175 19 boy NaN
B 180 23 girl NaN
C 169 21 boy NaN
>>> #从A到C左闭右闭
>>> df['height':'age']#对列是不可以进行切片的
Empty DataFrame
Columns: [height, age, sex, weight]
Index: []
>>> df.iloc[1:3]#隐式索引
height age sex weight
B 180 23 girl NaN
C 169 21 boy NaN
>>> #左开右闭
#！！！，DataFrame自身有bug，索引是汉字，有时无法检索
>>> df['sex']#直接用中括号时，索引表示的是列索引，切片表示的是行切片
A boy
B girl
C boy
D girl
Name: sex, dtype: object
>>> df['sex']['A':'B']
A boy
B girl
Name: sex, dtype: object
>>> df['sex']['A':'B']=['男','女']
>>> df
height age sex weight
A 175 19 ?? NaN
B 180 23 ? NaN
C 169 21 boy NaN
D 188 18 girl NaN
>>> df.loc['C','height']
169
>>> #检索行的时候，参数可以是多个
>>> #但是列无法完成该类型的操作
>>> df.values[0,2]
'\xc4\xd0'
>>> '\xc5\xae'#通过坐标进行检索
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
8：DataFrame的计算
de1=DataFrame(np.random.randint(0,150,size=(5,4)),index=['A','B','C','D','E'],columns=['a','b','c','e'])
>>> de1
a b c e
A 113 143 22 28
B 102 120 80 144
C 37 36 120 80
D 134 82 65 96
E 49 51 46 23
>>> de2=DataFrame(np.random.randint(0,150,size=(4,4)),index=['A','B','C','D'],columns=['a','b','c','e'])
>>> de2
a b c e
A 35 13 90 11
B 58 63 59 38
C 18 56 49 111
D 142 24 29 33
>>> de2.add(de1)
a b c e
A 148.0 156.0 112.0 39.0
B 160.0 183.0 139.0 182.0
C 55.0 92.0 169.0 191.0
D 276.0 106.0 94.0 129.0
E NaN NaN NaN NaN
>>> de2.add(de1,fill_value=0)
a b c e
A 148.0 156.0 112.0 39.0
B 160.0 183.0 139.0 182.0
C 55.0 92.0 169.0 191.0
D 276.0 106.0 94.0 129.0
E 49.0 51.0 46.0 23.0
>>> #fillvalue=0可以避免出现nan的情况
>>> de1+de2
a b c e
A 148.0 156.0 112.0 39.0
B 160.0 183.0 139.0 182.0
C 55.0 92.0 169.0 191.0
D 276.0 106.0 94.0 129.0
E NaN NaN NaN NaN
>>> de1=DataFrame(np.random.randint(0,150,size=(3,3)),index=['A','B','C'],columns=['a','b','c'])
>>> de1
a b c
A 140 4 101
B 120 101 127
C 127 71 91
>>> de2
a b c e
A 35 13 90 11
B 58 63 59 38
C 18 56 49 111
D 142 24 29 33
>>> de1.add(de2)
a b c e
A 175.0 17.0 191.0 NaN
B 178.0 164.0 186.0 NaN
C 145.0 127.0 140.0 NaN
D NaN NaN NaN NaN
>>> #无论是行索引还是列索引缺少了都要加NaN
>>> de1['a'].loc['A']=100
>>> de1
a b c
A 100 4 101
B 120 101 127
C 127 71 91
>>> de1['a']
A 100
B 120
C 127
Name: a, dtype: int32
>>> s1=de1['a']
>>> s1+de1
A B C a b c
A NaN NaN NaN NaN NaN NaN
B NaN NaN NaN NaN NaN NaN
C NaN NaN NaN NaN NaN NaN
>>> #对s1因为是Series索引是A,B,C，对于de1索引是a,b,c
>>> s2=de1.loc['A']
>>> s2
a 100
b 4
c 101
Name: A, dtype: int32
>>> s2+de1
a b c
A 200 8 202
B 220 105 228
C 227 75 192
>>> #列索引相同所以可以相加
>>> s2.index
Index([u'a', u'b', u'c'], dtype='object')
>>> de1.columns
Index([u'a', u'b', u'c'], dtype='object')
>>>
Python提供的函数：
+ add()
- sub(),或者multily()
* mul(),multiply()
/ truediv(),div(),divide()
// floordiv()
% mod()
** pow()
>>> ss=de1['a']
>>> ss
A 100
B 120
C 127
Name: a, dtype: int32
>>> de1.add(ss)
A B C a b c
A NaN NaN NaN NaN NaN NaN
B NaN NaN NaN NaN NaN NaN
C NaN NaN NaN NaN NaN NaN
>>> de1.add(ss,axis='index')#ss的索引变成a,b,c
a b c
A 200 104 201
B 240 221 247
C 254 198 218
>>> de1.add(ss,axis=0)
a b c
A 200 104 201
B 240 221 247
C 254 198 218
>>> de1.add(ss,axis=1)
A B C a b c
A NaN NaN NaN NaN NaN NaN
B NaN NaN NaN NaN NaN NaN
C NaN NaN NaN NaN NaN NaN
>>> #如果axis是零，则行是索引，所有列都有效
>>> #以列为单位进行操作，对所有列都有效，同理axis=1相反
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
9:DataFrame丢失数据的处理
处理丢失数据
有两种丢失数据 1 none 2 np.nan(NaN)
np.arange(0,10000)
#相同的计算，int运算的时间少于float，更少与object
Pandas中None与NaN都被视为np.nan
df = DataFrame({'age':[20,21,23,19,22],'salary':[10000,20000,11001,10101,21000]},index=['a','b','c','d','e'],columns=['age','salary','work'])
>>> df
age salary work
a 20 10000 NaN
b 21 20000 NaN
c 23 11001 NaN
d 19 10101 NaN
e 22 21000 NaN
>>> df.work['a':'b']
a NaN
b NaN
Name: work, dtype: object
>>> df.work['a':'b']='python'
>>> df
age salary work
a 20 10000 python
b 21 20000 python
c 23 11001 NaN
d 19 10101 NaN
e 22 21000 NaN
>>> >>> df.isnull()
age salary work
a False False False
b False False False
c False False True
d False False True
e False False True
>>> df.notnull()
age salary work
a True True True
b True True True
c True True False
d True True False
e True True False
>>> #根据获得的数据去除数据的空数据
>>> df.dropna()#去除含有空数据的行
age salary work
a 20 10000 python
b 21 20000 python
>>> #默认为行
>>> df.dropna(how='all')#去除全部为nan的行
age salary work
a 20 10000 python
b 21 20000 python
c 23 11001 NaN
d 19 10101 NaN
e 22 21000 NaN
>>> #所有都为null的才删除
>>> df.fillna(value='java')
age salary work
a 20 10000 python
b 21 20000 python
c 23 11001 java
d 19 10101 java
e 22 21000 java
>>> #使空数据修改为value值
#backfill,bfill,是向后填充ffill,pad是向前填充
>>> df
age salary work
a 20 10000 python
b 21 20000 python
c 23 11001 NaN
d 19 10101 NaN
e 22 21000 NaN
>>> df.fillna(method='backfill')#向后填充，实质是后面一行填充前面一行
age salary work
a 20 10000 python
b 21 20000 python
c 23 11001 NaN
d 19 10101 NaN
e 22 21000 NaN
>>> df.fillna(method='ffill')#向前填充
age salary work
a 20 10000 python
b 21 20000 python
c 23 11001 python
d 19 10101 python
e 22 21000 python
>>> df.fillna(method='ffill',inplace=True)#
>>> df
age salary work
a 20 10000 python
b 21 20000 python
c 23 11001 python
d 19 10101 python
e 22 21000 python
>>> obj=pd.Series(['blue','pure','yellow'],index=[0,2,4])
>>> obj
0 blue
2 pure
4 yellow
dtype: object
>>> obj.reindex(range(6),method='bfill')
0 blue
1 pure
2 pure
3 yellow
4 yellow
5 NaN
dtype: object
>>> #这是向后填充
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
3：总结
pandas的Series和DataFrame是构成表结构的两个重要的库，也是学习pandas的基础。