python小白学习笔记（1） pandas入门

基于《利用Python进行数据分析》和coursera上来自密歇根大学的Applied Data Science with Python 网课

Pandas介绍

有两个常用数据结构：Series和DataFrame

1 Series

1. 由一维的数组型对象，包含了一个值序列和索引，值序列可以理解为Numpy中的array.
   另一种考虑角度，可以认为他是一个长度固定且有序的字典，包含索引值和数据值，按照位置配对。

obj=pd.Series([4,7,-5,3],index=['d','a','b','c'])
obj2=pd.Series({'d':4,'a':7,'b':-5,'c':3})
obj2
-------------------------------------------
Out[]:
d  4
a  7
b  -5
c  3

#通过位置赋值改变索引
obj.index=['0','1','2','3']
obj
--------
out[]:
0  4
1  7
2  -5
3  3

#使用标签进行索引，注意中括号
obj2[['c','a','b']]
-----------------
Out[]:
c  3
a  7
b  -5

#bool值数组过滤、与标量相乘、或是应用数学函数，这些操作将保存索引值连接
obj2[obj2>0]
obj2*2
np.exp(obj2)

#判断是否存在
'b' in obj2
-------------
out[]:
True

2. 关于缺失值
   pandas用NA值标记缺失值，函数范畴使用isnull()和notnull()返回bool值

states=['a','c','b','d','e']
obj3=pd.Series({'d':4,'a':7,'b':-5,'c':3},index=states)
----------
out[3]:
a  7
c  3
b  -5
d  4
e  NaN

#函数判断是否是缺失值(两种方法）
pd.isnull(obj3)
obj4.isnull()

Series中的自动对齐索引也会产生NaN

obj2+obj3
----------------
out[4]:
a  7
c  3
b  -5
d  4
e  NaN

Series调用reindex方法(重建索引)也会引入缺失值

obj3=obj.reindex(['a','b','c','d','e'])

3. Series对象自身和其索引都有name属性，相当于是给整个Series对象和其index取名字

obj.name='population'
obj.index.name='state'

4. Series的values属性返回一个一维数组

obj.values
----
out[]:
array([3,7,-5])

2 DataFrame

1. 表示矩阵的数据表，包含已排列的列集合，每一列可以是不同的值类型（int,string,bool等）
2. 既有行索引也有列索引，索引可以共享。

2.1 构建DataFrame的第一种形式

利用包含等长度list或Numpy的array的字典形成。也可以是字典包含字典的形式。

data={'a':['oh','yes','ok'],'b':['wha','tht','wh'],'c':[10,20,30]}
frame=pd.DataFrame(data,columns=['b','c','a'])

# 选出头部5行	
frame.head()

#索引方式：按照字典型标记或者属性
frame['a']
frame.a

1. 同样也可以像Series一样加入index参数，frame中的列索引参数是columns，通过位置赋值改变行或列索引。（代码略）
2. 列的引用可以修改,赋值为标量值或值数组。
3. 可以通过column参数增添新的空列，并对列进行赋值；若被赋值的列不存在，直接建立新列。

#赋值一个标量
frame['d']=16
out[]:
   a    b   c  d
0  oh  wha 10 16
1  yes tht 20 16
2  ok  wh  30 16

#赋值一个数组
frame['d']=np.arange(3.)

7. 针对frame中用到判断，返回一个bool值的array

frame['e']=(frame['b']=='wha')

8. del 删除frame的列

del frame['e']

9. DataFrame中选取的列是数据的视图，不是拷贝，因此对Series的修改会映射到DataFrame中。

2.2 构造DataFrame的第二种形式

字典包含字典形式：字典的健作为列，内部字典的健作为行索引。

2.3 构造DataFrame的第三种形式

包含Series字典。

pdata={'a':frame['a'][:-1],'b':frame['b'][:-1]}

10. Frame的values属性返回n维数组

11. 不能单独去改变索引对象，但任意array和标签序列可以在内部转换为索引对象。

index[1]='m'   #typrerror

12. DataFrame的in判断：可以对columns或index属性进行判断。

3 基本功能

3.1 重建索引中的插值方法

即针对重建索引后，针对某些索引值之前并不存在，用插值填充到缺失值位置上。method可选参数：在重建索引时插值，ffill方法表示向前填充。

obj3.reindex([range(3),method='ffill']) #注意引号

reindex可以改变行索引、列索引、也可以同时改变。

3.2 较常用的loc方法–标签索引

iloc方法作用与loc方法类似，只是第一个参数不是标签名称，而是整数。
注意是中括号

states=['Texas','Utah','California']
frame.loc[['a','b','c','d'],states]

#loc也可以用切片
frame.loc[[:'c'],states]

3.3 轴向删除

简单来说就是给参数设定需要删除的内容所在的轴（上面提到过用del 删除列）,drop等方法中参数inplace=True表示直接操作原对象，： 若为False，则是默认值，默认创建新对象，并返回。

data.drop(['Texas','Utah]',axis='columns'，inplace=True) # or axis=1

3.4 索引、选择与过滤

普通python切片不包含尾部，但Series切片不同，包含首尾。
Series对于标签索引方法与dataframe不同，后者需要使用loc方法，而不能直接索引。
如果有包含整数的轴索引，使用标签索引或loc和iloc方法。

3.5 算术中的数据对齐

若存在某个索引对不同，返回索引对的并集，没有交叠的部分用NaN填充。
处理缺失值方法：fill_value

df1.add(df2,fill_value=0) #用0填充frame df1和frame df2的没有交叠部分的缺失值

df1.reindex(columns=df2.columns,fill_value=0)

3.6 dataframe和series间的操作–广播机制

arr-arr[0]  #arr的每一行做运算，即广播到各行

frame.sub(series1,axis=0)  # or axis='index' 广播到列

如果索引值同时不存在于dataframe和Series中，则对象会重建索引并形成联合，用缺失值填充。

3.7 函数应用

Numpy的通用函数==（逐元素数组方法）==对pandas对象也有效。
一个常用操作是将函数应用到函数一行或一列的一维数组上，利用dataframe的apply方法实现。

frame=pd.DataFrame(np.random.randn(4,3),index=['U','O','T','Or'],columns=['b','d','e'])
f=lambda x:x.max()-x.min()
frame.apply(f)
-------------------------------
Out[]:
b    1.920418
d    1.788882
e    1.255265
dtype: float64

使用applymap，将逐元素的函数应用到Series上;且Series自己的方法是map

f=lambda x:'%.2f'%x
frame['e'].map(f)
---------------
out[]:
U      0.47
O     -0.41
T     -0.28
Or     0.72
Name: e, dtype: object
-----------------------------
frame.applymap(f)
----------
out[]:
	b	d	e
U	1.53	0.85	0.47
O	-0.34	-1.10	-0.41
T	-0.31	-1.91	-0.28
Or	0.29	0.99	0.72

3.8 排序和排名

使用sort_index,目的是返回一个新的、排序好的对象。缺失值会被排序至尾部。设置参数by,作用类似于SQL。

frame.sort_values(by='b')
--------
out[]:
b	d	e
O	-0.344316	-1.104560	-0.413454
T	-0.313397	-1.911685	-0.279829
Or	0.294956	0.992794	0.717557
U	1.525719	0.848279	0.471139

排名：指利用Series和DataFrame的rank()函数对数组从1到有效数据点总数分配名次的操作。

In [10]:obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
In [11]:obj.rank()
Out [11]:
0    6.5	# index=0与index=2都是7，按正常排名的话，应该是6、7。此处是用（6+7）/2 = 6.5标识
1    1.0
2    6.5	# index=0与index=2都是7，按正常排名的话，应该是6、7。此处是用（6+7）/2 = 6.5标识
3    4.5	# index=3与index=6都是4，按正常排名的话，应该是4、5。此处是用（4+5）/2 = 4.5标识
4    3.0
5    2.0
6    4.5	# index=3与index=6都是4，按正常排名的话，应该是4、5。此处是用（4+5）/2 = 4.5标识
dtype: float64

In [12]:obj.rank(method='min')
Out [12]:
0    6.0	# index=0与index=2都是7，按正常排名的话，应该是6、7。此处是用最小排名6来标识
1    1.0
2    6.0	# index=0与index=2都是7，按正常排名的话，应该是6、7。此处是用最小排名6来标识
3    4.0	# index=3与index=6都是4，按正常排名的话，应该是4、5。此处是用最小排名4来标识
4    3.0
5    2.0
6    4.0	# index=3与index=6都是4，按正常排名的话，应该是4、5。此处是用最小排名4来标识
dtype: float64

In [14]:obj.rank(method='first')
Out [14]:
0    6.0	# index=0与index=2都是7，按正常排名的话，index=0先出现。此处是用排名6来标识
1    1.0
2    7.0	# index=0与index=2都是7，按正常排名的话，index=2后出现。此处是用排名7来标识
3    4.0	# index=3与index=6都是4，按正常排名的话，index=3先出现。此处是用排名4来标识
4    3.0
5    2.0
6    5.0	# index=3与index=6都是4，按正常排名的话，index=6后出现。此处是用排名5来标识
dtype: float64