Python基础 — Pandas

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的容器。

主要功能

1. 具备对齐功能的数据结构DataFrame（一维）、Series（二维）、Panel（三维）；
2. 集成时间序列功能；
3. 提供丰富的数学运算和操作；
4. 灵活处理缺失数据；

数据帧（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    13

3、从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.0

2、通过传递字典列表和行索引来创建数据帧(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.0

3、使用字典，行索引和列索引列表创建数据帧(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    4

1、列选择：通过从数据帧(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: float64

2、列添加：通过向现有数据框添加一个新列

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     NaN

3、列删除：列可以删除或弹出

# 使用前面的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: float64

2、按整数位置选择

        可以通过将整数位置传递给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: float64

3、行切片

        可以使用:运算符选择多行。

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     4

4、添加行

        使用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  8

5、删除行

        使用 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: object

这里没有传递任何索引，因此默认情况下，它分配了从0 到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: float64

        2、索引顺序保持不变，缺少的元素使用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])

执行结果 

1

2、检索系列中的前三个元素

如果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: int64

3、检索最后三个元素

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'])

执行结果 

1

2、使用索引标签值列表检索多个元素。

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: int64

3、如果不包含标签，则会出现异常。

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 pd

2、导入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.shape

2、数据表基本信息（维度、列名称、数据格式、所占空间等）

df.info()

3、每一列数据的格式

df.dtypes

4、某一列格式

df['B'].dtype

5、判断空值

df.isnull()

6、查看某一列的唯一值

df['B'].unique()

7、查看数据表的值

df.values

8、查看列名称

df.columns

9、查看前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']=1

7、对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')