Python大数据分析之Pandas入门基础1_series 加号

Pandas是Python大数据分析的必备库之一，调用库的代码如下：

import pandas as pd
1

在开始大数据分析之前，需要了解Pandas的基础知识：

1. 数据结构：数据在Pandas的处理过程中存在的形式，决定了数据特性和数据处理流程；
2. 主要的功能函数：包括索引、重新索引、数据的增删改、排序与排名等；
3. 常见运算函数：加减乘除、绝对值、统计分析值等等；
4. 附加功能：文件读取、数据库交互、网站API等（粗略介绍，后续专题）。

一、数据结构
Pandas的数据结构主要有两种：Series 和 DataFrame；

from pandas import Series, DataFrame
1

1. series ：一维数组（类似），由一组 数据 和与之相关联的 标签（索引） 组成
   1）.创建Series：obj=pd.Series([3,4,6,8],index=[1,2,3,4])；
   2）.获取Series数据中的数值和索引：
   obj.values( ) #获取obj中的数值；
obj.index( ) #获取obj中的索引
   3）.字典可 直接用于构建 Series，且相关运算仍适用于 此数据结构：
   例如：
   data={'a':100,'b':200,'c':300,'d':400}
x=pd.Series(data)
x

   输出：
   a 100
b 200
c 300
d 400
dtype: int64
   4）.Series的索引更改：即，前面的“a”……的改变，可以改变原索引的顺序，也可以改变原索引的值；
   利用字典的键，以改变Series的顺序：
   state=['c','b','d','a']
x1=pd.Series(x1,index=state);
   输出：按照c,b,d,a的顺序，重新排列（数组中的数字随之变动）；
   利用 x.index(1,2,3,4)，
   可以对原始 Series的索引号进行更改。

   5）.Series的特性：相同索引的数据，运算时自动对齐
   当两个Series进行运算时，会判断两数组的索引，将相同索引的数值进行元素级运算；不同索引的行（列），返回NaN：
   eg：x2=pd.Series([200,300,400,500],index=['b','c','d','e'])
x2+x
   输出：
   a NaN
b 400.0
c 600.0
d 800.0
e NaN
   6）.Series的索引可以进行运算：（类似字典的键）
   'b'in x1
   输出： True
   'e'in x1
   输出：False
   7）.Series的索引和数值都可命名：
   索引和数值（即每一列），均存在name属性：
   x2.name=''
x2.index.name=''

2.DataFrame :多维数组，类似多个相同索引的Series组成；
1）利用字典或嵌套字典进行数组定义：（行索引默认为0：n）

data = {'state': ['Ohio', 'Ohio','Nevada', 'Ohio',  'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(data)
frame
1
2
3
4
5

输出：

	state	year	pop
0	Ohio	2000	1.5
1	Ohio	2001	1.7
2	Nevada	2002	3.6
3	Ohio	2001	2.4
4	Nevada	2002	2.9
5	Nevada	2003	3.2
1
2
3
4
5
6
7

或者嵌套字典：（外层字典的键为列索引；行索引会以 内层字典的键 为准）

data2={'Nevada': {2001: 2.4, 2002: 2.9},
       'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
frame2 = pd.DataFrame(pop)
frame2
1
2
3
4

输出：

	 Nevada	Ohio
2001	2.4	1.7
2002	2.9	3.6
2000	NaN	1.5
1
2
3
4

2）对字典型数据，按照需要的顺序，重新排列行列，需要用到 .DataFrame(……,columns=[],index=[])；（不存在的行列索引，以NaN填充）
例如：

frame3 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'], index=['one', 'two', 'three', 'four', 'five', 'six'])
frame3
1
2

输出：

	year	state	pop	debt
one	2000	Ohio	1.5	NaN
two	2001	Ohio	1.7	NaN
three	2002	Nevada	3.6	NaN
four	2001	Ohio	2.4	NaN
five	2002	Nevada	2.9	NaN
six	2003	Nevada	3.2	NaN
1
2
3
4
5
6
7

3）当数组行列数较大时，可以列出前5行展示，frame.head()；
4）数组的行、列索引，可以直接更改：（注意：索引的 维度 必须与原数组相同）

frame2.columns=[1,2,3,4]
frame2.index=[1,2,3,4,5,6]    #  将数组的行、列索引，全部更改为1起始
1
2

5）当数组 内部数值 需要修改时，直接在提取的行列中赋值：

frame2['debt'] = 16.5
frame2[2:3]= np.arange(4)
frame2['debt'] = pd.Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])   #  指定行、指定列，数值修改
1
2
3

6）当进行简单的数组行列提取（索引）时，可以直接在数组名后提取：

frame2['state']
frame2.year
frame2[2:3]	#frame2['three']   行索引是不能直接提取，此方法错误，后续功能函数中会使用loc和iloc函数实现
1
2
3

7）DataFrame的数组与Series一样，frame2.values，返回数组array形式数据；

二、功能函数

1. 索引、切片
   索引：在Series中，索引可以利用索引名，直接索引：
   obj2['a']
   在DataFrame中，索引比较复杂：
   1）当对 列向量 索引，返回对应列向量时，可以使用索引名字，也可以使用loc和iloc函数（见后文）；
   frame2['state'];
   frame2.year;
   2）当单独对 行向量 索引时，必须对行序号索引，也可以使用loc函数和iloc函数；
   frame2[0:1] # 索引带数组的第一行;
   Tips：不能以以上两种方式，直接进行 行、列同时 索引；

   3）行、列同时索引：loc函数和iloc函数
   a.loc( ):
   以行、列 名 索引，索引时不能通过赋值来改变数组元素；
   data.loc['Utah',['one','four']] # 索引'Utah' 行，'one','four' 列；
   当使用loc( )函数 单独 索引行 或 列，需要保留行、列的部分，如下：
   data.loc['Utah',:]；
   data.loc[:,['one']]；
   b.iloc( ):
   以行、列 序号 索引，索引时可以通过赋值来改变数值；
   data.iloc[1:3,0:3] == data.iloc[[1:3],0:3] == data.iloc[1:3,[0:3]] ==data.iloc[[1:3],[0:3]];
   data.iloc[:,0:3] # 与MATLAB类似，索引所有行，0到2列；

   4）当数组的行列索引，存在重复索引值时，返回多个Series变量、或多维数组。

   5）最大、最小值的位置索引：.idxmin(axis=1) 和 .idxmax(); 默认，axis=0；

   切片：在Pandas中，可以利用 索引名 切片与利用 索引序号切片，存在差异（暂时只分析Series类型）：
   obj2 = pd.Series(np.arange(4.), index=["1","2","3","4"])；
   obj2[1:3] #索引序号的切片，不包含末端元素；
   输出：
   2 1.0；
   3 2.0；
   obj2['1':'3'] # 索引名的切片，包含末端元素；
   输出：
   1 0.0；
   2 1.0；
   3 2.0；

2. 重新索引：按照需求的索引顺序排序，并赋值给新变量；当新的行、列索引在原数组中不存在，则返回NaN，或使用method作插值；
   obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'], method=' ')# 按照新的索引顺序排列，不存在的返回NaN；
   frame3=frame.reindex(['a', 'd', 'c'],columns=['California', 'Ohio','Texas']) # 按照新索引顺序排列；
   method存在两种：‘ffill’ —— 前向填充；‘bfill’ —— 后向填充；
   或者，.reindex(…… ,fill_value=0)：多出来的列赋值为0，多用于两数组之间的重新索引。

3. 数据的增、删、查、改（部分查、改内容，在定义部分（第一部分）已阐述）
   1）DataFrame数组的增加：
   frame.reindex(columns=list('abcde'),fill_value=0)；#依靠重新排序，增加需要的列，默认增加的列为NaN，可以通过fill_value统一赋值；
   或者利用 .insert() 增加行、列：
   col_name=frame2.columns.tolist() # 将列索引提取，赋值给中间变量
col_name.insert(col_name.index('year')+1,'D') # 在“year”列后面，增加列“D”
col_name.insert(3,'C') # 在第4列处，增减列|“C”
frame3=frame2.reindex(columns=col_name,fill_value=0) # 对新列重新排序，并赋值给新变量frame3
frame3
   输出：

    	year	D	state	C	pop	debt
    one	2000	0	Ohio	0	1.5	NaN
    two	2001	0	Ohio	0	1.7	NaN
    three	2002	0	Nevada	0	3.6	NaN
    four	2001	0	Ohio	0	2.4	NaN
    five	2002	0	Nevada	0	2.9	NaN
    six	2003	0	Nevada	0	3.2	NaN
   1
   2
   3
   4
   5
   6
   7

   同理，行的增加也相同：

   ind_name=frame2.index.tolist() # 将行索引提取，赋值给中间变量； ind_name.insert(ind_name.index('one')+1,'k') # 在“one”行后面，增加列“k”； ind_name.insert(3,'p') # 在第4行处，增减列“p”； frame3=frame2.reindex(index=ind_name,fill_value=0) # 对新行重新排序，并赋值给新变量frame3； frame3

   2）数组的行、列删除：.drop()
   当数据类型为Series：

   obj.drop(['c'],axis=0) #从数据中删除‘c’；

   当数据类型为DataFrame时：

   obj.drop(['one','two'],axis=0) #从 行标签 中，删除‘one’、‘two’两行；
   obj.drop(['day','year'],axis=1，inplace=True) #从 列标签 中，删除‘day’、‘year’两行，并且不返回新对象，就地修改原数组；

   3） 数组中，行、列、元素的查找：
   行、列的查找：

     state' in frame2 	#列索引的查找；
    'three' in frame2.T	#行索引的查找，将矩阵转置后，行变列查找；
    'one' in frame2.state  #  行索引的查找，可以提取一列，转化为Series，继续使用Series的	 in  查找；
   1
   2
   3

   数组元素的查找：

   obj.isin(['','']) #返回布尔型数值

   也可以利用 enumerate() 函数，返回行列索引# 看看是否为空，后续会继续 此内容的研究。

4. 排序和排名
   排序：.sort_index(axis=0,ascending=False)；以 行索引 来排序，默认是升序（True），此时为降序；
   1）当数据为Series型时：
   obj.sort_index()；
   obj.sort_values() #针对数组内数值大小进行排序；
   2）当数据为DataFrame型时：
   frame.sort_values(by='a',ascending=True) #依据 ‘a’ 列的数值大小，进行排序,默认升序；
   frame.sort_values(axis=1,ascending=False) #依据 列索引 的大小，进行排序，此时降序。

   排名：rank( )函数，依据数值的大小，默认是升序，相同数值大小的名次为序号均值；

   obj.rank(ascending = False,method='max')；

   1）ascending = True，（缺省）默认值，升序；ascending = False，降序；
   2）method有多重取值，决定相同数值大小时，排序序号的数值；
   当取值为：
   ‘max’时，相同数值的序号，会以最大rank名次来统一序号；
   ‘min’时，相同数值的序号，会以最小rank名次来统一序号；
   ‘average’时，相同数值的序号，会以平均rank名次来统一序号；（缺省）
   ‘dense’时，相同数值的序号，以最小rank统一，且后续序号紧随其后（例如：4，4，5）

5. 其他： NaN值检测
   当数组中存在NaN值时，可以通过 .isnull() 来检测，并用于后续的筛选功能：
   pd.isnull(frame2)；
   frame2.isnull()；

   判断不为NaN时，
   pd.notnull(frame2)。

三、运算函数

1. 逻辑计算（布尔型运算）
   针对Series型和Dataframe型数据，简单的逻辑运算就是判断大小：
   Series：
   x[x>3] # x中，元素的值 ＞3 得才保留 ;
   Dataframe：
   data[data<3]=0 # 将data中，＜3 的值全部赋为0；

2. 同数据类型的加减运算：即Series的运算，或Dataframe的运算
   1）Series的相加，‘+’加号就可以实现：s1+s2，元素之间 相加；
   当Series之间存在不同索引时（即只有一方存在的索引），返回NaN；
   2)Dataframe的相加，pd1+pd2；元素之间 直接相加；（相加时，索引自动对齐）
   当行、列索引相同时，对应元素才能运算，缺失索引的运算，返回NaN值。

   3）函数 实现运算功能：
   df1.add(df2,fill_value=1) # 函数实现相加功能，并且两数组间缺失索引的行列相加结果，使用 1 来代替。
   4）运算过程中，参数的翻转：
   1/df1 == df1.rdiv(1);
   df2/df1 == df1.rdiv(df2);

3. 不同类型数据的运算：Dataframe 和 Series 的运算-广播
   在两者之间的计算中，Dataframe 会将 Series 的标签与指定轴匹配（默认是与列标签匹配，axis=1），并依次向后/下继续运算：
   frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),columns=list('bde'),index=['Utah', 'Ohio', 'Texas', 'Oregon'])
series=frame.iloc[0] # 第 1 行
series1 = frame.iloc[:,1] #frame的第 2 列
   方法1：
   frame + series # 匹配列标签，并依次向下广播;
   方法2：
   frame.sub(series1, axis=0) # 默认匹配列标签，axis=0（index）时，匹配行标签，依次向后广播计算。

4. 统计分析计算：
   1） 一次性产生多种统计分析计算的结果
   （Dataframe 输出：计数、均值、方差、四分位数、极值，Series ：计数、种类……）：
   df.describe()；

   2）单独计算均值、求和、（取绝对值）等：
   frame=pd.DataFrame();
   np.abs #取绝对值；
   frame.sum(axis=1) # 求和，默认 求每列的和，当axis=1时，求 每行 的和。

   3）计算Series 中出现的各值的频率：
   obj.value_counts() #计算各值出现的频率，默认是降序排列；
   pd.value_counts(obj.values,sort=False) # 计算各值出现的频率，不在排序；
   4）提取Series 中，不重复的元素：
   uniques = obj.unique() #去除重复的元素，每个元素只保留一个；
   5）Dataframe 数据的各值频率统计，利用.apply函数实现：
   data = pd.DataFrame({'Qu1': [1, 3, 4, 3, 4], 'Qu2': [2, 3, 1, 2, 3],'Qu3': [1, 5, 2, 4, 4]})
result = data.apply(pd.value_counts).fillna(0) # 默认：以 列向量 为单位，输出每列中 元素 的出现频率，列索引保持不变
result = data.apply(pd.value_counts,axis=1).fillna(0) # axis=1，以 行向量 为单位，输出每行 元素 的频率，行索引保持不变；

5. 函数应用：.apply( )
   针对lambda函数在Pandas的应用：
   f=lambda x:x.max()-x.min();
   frame.apply(f,axis=1) # 输出 每一行 的极差。

四、文件读取、数据库交互
1.读取文件：

pd.read_csv('		');
pd.read_table('		')
pd.read_excel('		')
pd.read_sql('		');
1
2
3
4

针对没有标题行的数据，使用参数进行定义：

pd.read_csv('		', header=None)		#默认使用0,	1，2……; 
  pd.read_csv('		', names=[‘……’])	#以自定义的名字命名；
1
2

写入excel文件：

pd.ExcelWriter(	)  
1

2.数据库交互

import sqlalchemy as sqla
db=sqla.create_engine()
pd.read_sql('select *from ……', db)
1
2
3

文件交互和数据库的详细内容见后续文章