Pandas -- 简介
Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
数据结构
Series：一维数组，与Numpy中的一维array类似。二者与Python基本的数据结构List也很相近，其区别是：List中的元素可以是不同的数据类型，而Array和Series中则只允许存储相同的数据类型，这样可以更有效的使用内存，提高运算效率。
Time- Series：以时间为索引的Series。
DataFrame：二维的表格型数据结构。很多功能与R中的data.frame类似。可以将DataFrame理解为Series的容器。以下的内容主要以DataFrame为主。
Panel ：三维的数组，可以理解为DataFrame的容器。
主要功能
- 具备对齐功能的数据结构DataFrame（一维）、Series（二维）、Panel（三维）；
- 集成时间序列功能；
- 提供丰富的数学运算和操作；
- 灵活处理缺失数据；
数据帧（DataFrame）
数据帧(DataFrame)是二维数据结构，即数据以行和列的表格方式排列。
数据帧(DataFrame)的功能特点：
- 潜在的列是不同的类型
- 大小可变
- 标记轴(行和列)
- 可以对行和列执行算术运算
pandas.DataFrame
pandas中的DataFrame可以使用以下构造函数创建 ：
pandas.DataFrame( data, index, columns, dtype, copy)构造函数的参数如下 ：
| 编号 | 参数 | 描述 |
|---|---|---|
| 1 | data | 数据采取各种形式，如:ndarray，series，map，lists，dict，constant和另一个DataFrame |
| 2 | index | 对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)，如果没有传递索引值 |
| 3 | columns | 对于列标签，可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的情况下才是这样。 |
| 4 | dtype | 每列的数据类型。 |
| 5 | cope | 如果默认值为False，则此命令(或任何它)用于复制数据。 |
创建DataFrame
Pandas数据帧(DataFrame)可以使用各种输入创建，如 ：
- 列表
- 字典
- 系列
- Numpy ndarrays
- 另一个数据帧(DataFrame)
1、创建一个空的数据帧（DataFrame）
创建基本数据帧是空数据帧。
#创建空数据帧
import pandas as pd
df = pd.DataFrame()
print(df)执行结果
Empty DataFrame
Columns: []
Index: []2、从列表创建数据帧（DataFrame）
可以使用单个列表或列表列表创建数据帧。①使用单个列表创建数据帧
import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print(df)执行结果
0
0 1
1 2
2 3
3 4
4 5
②使用多个列表创建数据帧
import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print(df)执行结果
Name Age
0 Alex 10
1 Bob 12
2 Clarke 133、从ndarray/Lists的字典来创建数据帧（DataFrame）
所有的ndarrays必须具有相同的长度。如果传递了索引(index)，则索引的长度应等于数组的长度。如果没有传递索引，则默认情况下，索引将为
range(n)，其中n为数组长度。 ①分配给每个使用函数range(n)的默认索引。
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print(df)执行结果
Age Name
0 28 Tom
1 34 Jack
2 29 Steve
3 42 Ricky②使用数组创建一个索引的数据帧
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print(df)index参数为每行分配一个索引，执行结果
Age Name
rank1 28 Tom
rank2 34 Jack
rank3 29 Steve
rank4 42 Ricky从列表创建数据帧DataFrame
字典列表可作为输入数据传递以用来创建数据帧(DataFrame)，字典键默认为列名。
1、通过传递字典列表来创建数据帧(DataFrame)
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print(df)执行结果
a b c
0 1 2 NaN
1 5 10 20.02、通过传递字典列表和行索引来创建数据帧(DataFrame)
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print(df)执行结果
a b c
first 1 2 NaN
second 5 10 20.03、使用字典，行索引和列索引列表创建数据帧(DataFrame)
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
#对于两个列索引，值与字典键相同
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])
#有两个列索引，一个索引有其他名称
df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
print(df1)
print(df2)执行结果
#输出df1
a b
first 1 2
second 5 10
#输出df2
a b1
first 1 NaN
second 5 NaN 注意：df2 使用字典键以外的列索引创建DataFrame; 因此，附加了NaN到位置上。 而df1是使用列索引创建的，与字典键相同，所以也附加了NaN
从系列的字典来创建DataFrame
字典的系列可以传递以形成一个DataFrame。 所得到的索引是通过的所有系列索引的并集。
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df)对于第一个系列，观察到没有传递标签'd'，但在结果中，对于d标签，附加了NaN。执行结果
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 41、列选择：通过从数据帧(DataFrame)中选择一列
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df ['one'])执行结果
a 1.0
b 2.0
c 3.0
d NaN
Name: one, dtype: float642、列添加：通过向现有数据框添加一个新列
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
# 通过传递新的系列，向具有列标签的现有DataFrame对象添加新的列
print ("通过系列添加新列:")
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print(df)
print ("使用DataFrame中的现有列添加新列:")
df['four']=df['one']+df['three']
print(df)执行结果
通过系列添加新列:
one two three
a 1.0 1 10.0
b 2.0 2 20.0
c 3.0 3 30.0
d NaN 4 NaN
使用DataFrame中的现有列添加新列:
one two three four
a 1.0 1 10.0 11.0
b 2.0 2 20.0 22.0
c 3.0 3 30.0 33.0
d NaN 4 NaN NaN3、列删除：列可以删除或弹出
# 使用前面的DataFrame，我们将删除一个列
# 使用del函数
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']),
'three' : pd.Series([10,20,30], index=['a','b','c'])}
df = pd.DataFrame(d)
print ("Dataframe is:")
print(df)
# 使用del函数
print ("使用del函数删除第一行:")
del df['one']
print(df)
# 使用pop函数
print ("使用pop函数删除:")
df.pop('two')
print(df)执行结果
Dataframe is:
one three two
a 1.0 10.0 1
b 2.0 20.0 2
c 3.0 30.0 3
d NaN NaN 4
使用del函数删除第一行:
three two
a 10.0 1
b 20.0 2
c 30.0 3
d NaN 4
使用pop函数删除第二行:
three
a 10.0
b 20.0
c 30.0
d NaN行选择，添加和删除
1、标签选择
可以通过将行标签传递给loc()函数来选择行
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df.loc['b'])执行结果
one 2.0
two 2.0
Name: b, dtype: float642、按整数位置选择
可以通过将整数位置传递给iloc()函数来选择行。
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df.iloc[2])执行结果
one 3.0
two 3.0
Name: c, dtype: float643、行切片
可以使用:运算符选择多行。
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df[2:4])执行结果
one two
c 3.0 3
d NaN 44、添加行
使用append()函数将新行添加到DataFrame。
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
print(df)执行结果
a b
0 1 2
1 3 4
0 5 6
1 7 85、删除行
使用 drop（标签）函数从DataFrame中删除或删除行。 如果标签重复，则会删除多行。
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
# 删除标签为0的行
df = df.drop(0)
print(df)执行结果
a b
1 3 4
1 7 8系列（Series）
系列(Series)是能够保存任何类型的数据(整数，字符串，浮点数，Python对象等)的一维标记数组。
轴标签统称为索引。
Pandas系列可以使用以下构造函数创建 ：
pandas.Series( data, index, dtype, copy)构造函数的参数如下：
| 编号 | 参数 | 描述 |
|---|---|---|
| 1 | data | 数据采取各种形式，如： ndarray，list，constants |
| 2 | index | 索引值必须是唯一的和散列的，与数据的长度相同。 默认np.arange(n) ，如果没有索引被传递。 |
| 3 | dtype | dtype 用于数据类型。如果没有，将推断数据类型 |
| 4 | copy | 复制数据，默认为false |
可以使用各种输入创建一个系列，如 :
- 数组
- 字典
- 标量值或常数
创建一个空的系列
创建一个基本系列是一个空系列。
#创建空系列
import pandas as pd
s = pd.Series()
print(s)执行结果
Series([], dtype: float64)从ndarray创建一个系列
如果数据是ndarray，则传递的索引必须具有相同的长度。 如果没有传递索引值，那么默认的索引将是范围(n)，其中n是数组长度，即[0,1,2,3…. range(len(array))-1] - 1]。
#从ndarray创建系列
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data)
print(s)执行结果
0 a
1 b
2 c
3 d
dtype: object0 到len(data)-1 的索引，即：0 到3。import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data,index=[100,101,102,103])
print(s)在这里传递了索引值。现在可以在输出中看到自定义的索引值。
输出结果
100 a
101 b
102 c
103 d
dtype: object从字典创建一个系列
1、字典(dict)可以作为输入传递，如果没有指定索引，则按排序顺序取得字典键以构造索引。 如果传递了索引，索引中与标签对应的数据中的值将被拉出。
#从字典创建一个系列
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print(s)执行结果
a 0.0
b 1.0
c 2.0
dtype: float642、索引顺序保持不变，缺少的元素使用NaN(不是数字)填充。
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data,index=['b','c','d','a'])
print(s)执行结果
b 1.0
c 2.0
d NaN
a 0.0
dtype: float64从标量创建一个系列
如果数据是标量值，则必须提供索引。将重复该值以匹配索引的长度。
#从标量创建一个系列
import pandas as pd
import numpy as np
s = pd.Series(5, index=[0, 1, 2, 3])
print(s)执行结果
0 5
1 5
2 5
3 5
dtype: int64从具有位置的系列中访问数据
系列中的数据可以使用类似于访问ndarray中的数据来访问。
1、检索第一个元素
比如已经知道数组从零开始计数，第一个元素存储在零位置等等。
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#检索第一个元素
print(s[0])执行结果
12、检索系列中的前三个元素
如果a: 被插入到其前面，则将从该索引向前的所有项目被提取。 如果使用两个参数(使用它们之间)，两个索引之间的项目(不包括停止索引)。
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#检索系列中前三个元素
print(s[:3])执行结果
a 1
b 2
c 3
dtype: int643、检索最后三个元素
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#检索系列中最后三个元素
print(s[-3:])执行结果
c 3
d 4
e 5
dtype: int64使用标签检索数据(索引)
一个系列就像一个固定大小的字典，可以通过索引标签获取和设置值。
1、使用索引标签值检索单个元素。
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#检索单个元素
print(s['a'])执行结果
12、使用索引标签值列表检索多个元素。
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#检索多个元素
print(s[['a','c','d']])执行结果
a 1
c 3
d 4
dtype: int643、如果不包含标签，则会出现异常。
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#检索多个元素
print(s['f'])执行结果
…
KeyError: 'f'Pandas -- 用法
一、生成数据表
1、首先导入pandas库，一般都会用到numpy库，所以我们先导入备用
import numpy as np
import pandas as pd2、导入CSV或者xlsx文件
df = pd.DataFrame(pd.read_csv('name.csv',header=1))
df = pd.DataFrame(pd.read_excel('name.xlsx'))3、用pandas创建数据表
df = pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006],
"date":pd.date_range('20180102', periods=6),
"city":['Beijing ', 'SH', ' guangzhou ', 'Shenzhen', 'shanghai', 'BEIJING '],
"age":[23,44,54,32,34,32],
"category":['100-A','100-B','110-A','110-C','210-A','130-F'],
"price":[1200,np.nan,2133,5433,np.nan,4432]},
columns =['id','date','city','category','age','price'])1、维度查看
df.shape2、数据表基本信息（维度、列名称、数据格式、所占空间等）
df.info()3、每一列数据的格式
df.dtypes4、某一列格式
df['B'].dtype5、判断空值
df.isnull()6、查看某一列的唯一值
df['B'].unique()7、查看数据表的值
df.values8、查看列名称
df.columns9、查看前10行数据、后10行数据
df.head() #默认前10行数据
df.tail() #默认后10 行数据1、用数字0填充空值
df.fillna(value=0)2、使用列prince的均值对NA进行填充
df['prince'].fillna(df['prince'].mean())3、清楚city字段的字符空格
df['city'] = df['city'].map(str.strip)4、大小写转换
df['city']=df['city'].str.lower()5、更改数据格式
df['price'].astype('int')6、更改列名称
df.rename(columns={'category': 'category-size'})7、删除后出现的重复值
df['city'].drop_duplicates()8、删除先出现的重复值
df['city'].drop_duplicates(keep='last')9、数据替换
df['city'].replace('sh', 'shanghai')四、数据预处理
df1=pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006,1007,1008],
"gender":['male','female','male','female','male','female','male','female'],
"pay":['Y','N','Y','Y','N','Y','N','Y',],
"m-point":[10,12,20,40,40,40,30,20]})1、数据表合并
df_inner=pd.merge(df,df1,how='inner') # 匹配合并，交集
df_left=pd.merge(df,df1,how='left') #
df_right=pd.merge(df,df1,how='right')
df_outer=pd.merge(df,df1,how='outer') #并集2、设置索引列
df_inner.set_index('id')3、按照特定列的值排序
df_inner.sort_values(by=['age'])4、按照索引列排序
df_inner.sort_index()5、如果prince列的值>3000，group列显示high，否则显示low
df_inner['group'] = np.where(df_inner['price'] > 3000,'high','low')6、对复合多个条件的数据进行分组标记
df_inner.loc[(df_inner['city'] == 'beijing') & (df_inner['price'] >= 4000), 'sign']=17、对category字段的值依次进行分列，并创建数据表，索引值为df_inner的索引列，列名称为category和size
pd.DataFrame((x.split('-') for x in df_inner['category']),index=df_inner.index,columns=['category','size']))8、将完成分裂后的数据表和原df_inner数据表进行匹配
df_inner=pd.merge(df_inner,split,right_index=True, left_index=True)主要用到的三个函数：loc,iloc和ix，loc函数按标签值进行提取，iloc按位置进行提取，ix可以同时按标签和位置进行提取。
1、按索引提取单行的数值
df_inner.loc[3]2、按索引提取区域行数值
df_inner.iloc[0:5]3、重设索引
df_inner.reset_index()4、设置日期为索引
df_inner=df_inner.set_index('date') 5、提取4日之前的所有数据
df_inner[:'2018-01-04']6、使用iloc按位置区域提取数据
df_inner.iloc[:3,:2] #冒号前后的数字不再是索引的标签名称，而是数据所在的位置，从0开始，前三行，前两列。7、适应iloc按位置单独提起数据
df_inner.iloc[[0,2,5],[4,5]] #提取第0、2、5行，4、5列8、使用ix按索引标签和位置混合提取数据
df_inner.ix[:'2018-01-03',:4] #2018-01-03号之前，前四列数据9、判断city列的值是否为北京
df_inner['city'].isin(['beijing'])10、判断city列里是否包含beijing和shanghai，然后将符合条件的数据提取出来
df_inner.loc[df_inner['city'].isin(['beijing','shanghai'])] 11、提取前三个字符，并生成数据表
pd.DataFrame(category.str[:3])使用与、或、非三个条件配合大于、小于、等于对数据进行筛选，并进行计数和求和。
1、使用“与”进行筛选
df_inner.loc[(df_inner['age'] > 25) & (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']]
2、使用“或”进行筛选
df_inner.loc[(df_inner['age'] > 25) | (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']].sort(['age'])
3、使用“非”条件进行筛选
df_inner.loc[(df_inner['age'] > 25) | (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']].sort(['age'])
4、对筛选后的数据按city列进行计数
df_inner.loc[(df_inner['city'] != 'beijing'), ['id','city','age','category','gender']].sort(['id']).city.count()
5、使用query函数进行筛选
df_inner.query('city == ["beijing", "shanghai"]')6、对筛选后的结果按prince进行求和
df_inner.query('city == ["beijing", "shanghai"]').price.sum()主要函数是groupby和pivote_table
1、对所有的列进行计数汇总
df_inner.groupby('city').count()2、按城市对id字段进行计数
df_inner.groupby('city')['id'].count()3、对两个字段进行汇总计数
df_inner.groupby(['city','size'])['id'].count()4、对city字段进行汇总，并分别计算prince的合计和均值
df_inner.groupby('city')['price'].agg([len,np.sum, np.mean]) 数据采样，计算标准差，协方差和相关系数
1、简单的数据采样
df_inner.sample(n=3) 2、手动设置采样权重
weights = [0, 0, 0, 0, 0.5, 0.5]
df_inner.sample(n=2, weights=weights) 3、采样后不放回
df_inner.sample(n=6, replace=False) 4、采样后放回
df_inner.sample(n=6, replace=True)
5、数据表描述性统计
df_inner.describe().round(2).T #round函数设置显示小数位，T表示转置
6、计算列的标准差
df_inner['price'].std()7、计算两个字段间的协方差
df_inner['price'].cov(df_inner['m-point'])
8、数据表中所有字段间的协方差
df_inner.cov()9、两个字段的相关性分析
df_inner['price'].corr(df_inner['m-point']) #相关系数在-1到1之间，接近1为正相关，接近-1为负相关，0为不相关
10、数据表的相关性分析
df_inner.corr()
分析后的数据可以输出为xlsx格式和csv格式
1、写入Excel
df_inner.to_excel('excel_to_python.xlsx', sheet_name='bluewhale_cc')
2、写入到CSV
df_inner.to_csv('excel_to_python.csv')