Python数据分析库--Pandas

一、基本概念

Pandas是一个强大的分析结构化数据的工具集；它的使用基础是Numpy（提供高性能的矩阵运算）；用于数据挖掘和数据分析，同时也提供数据清洗功能。Pandas常与numpy和matplotlib一同使用。

Pandas有两个主要数据结构：Series和DataFrame。

二、Series

Series可以理解为带标签的一维数组，可存储整数、浮点数、字符串、Python 对象等类型的数据。若不指定索引，则默认索引从0开始，此时其功能类似数组，但是，它又跟数组不一样，一个数组只能存放同一类型的元素，Series却可以在存放不同类型的元素，具体如下。

import pandas as pd

#Series基础
s = pd.Series(['a',3.14,30])
print(s)
'''
0       a
1    3.14
2      30
dtype: object
'''

print(s[0]+'bc') #打印 abc
print(s[1]*20) #打印 62.800000000000004
print(s[2]-10) #打印 20

当然Series也可以自定义索引，此时其功能就类似于字典。但是，它又和字典不同，字典的索引不允许重复，而Series却可以，具体如下

import pandas as pd

#Series指定索引
s = pd.Series(['a',3.14,30],index=[100,101,101])
print(s)
'''
100       a
101    3.14
101      30
dtype: object
'''

'''
当Series中出现重复索引时，对某一个重复索引的操作，会使所以该索引的元素都改变
'''

print(s[101])
'''
101    3.14
101      30
dtype: object
'''

s[101] += 1
print(s[101])
'''
101    4.14
101      31
dtype: object
'''

前面说到Series的功能有些类似于字典，所以当然可以使用字典创建一个Series对象

import pandas as pd

#利用字典创建Series
dict = {'c':1, 'a':2, 'b':3.14}
s = pd.Series(dict) #可以看到，字典和Series的索引都可以是字符串类型，这也是大大区别于List的地方
print(s)
'''
c    1.00
a    2.00
b    3.14
dtype: float64

可以看结果dtype: float64，这是因为创建dict的时候元素值出现了3.14，但是字典不支持存放不同类型元素
所以，在创建字典的时候，就自动向下转化，将所有元素类型转化为了浮点型，所以使用该字典创建的Series的dtype是float64
'''

#获取Series对象的所有索引和所有元素值
print(s.index) #打印 Index(['c', 'a', 'b'], dtype='object')
print(s.values) #打印 [1.   2.   3.14]

Series中最重要的一个功能是：它会在算术运算中自动对齐不同索引的数据，寻找对应索引所指向的元素进行运算，如果找不到对应的索引，则不参与此次运算，返回一个NaN（Not a Number），具体如下

import pandas as pd

#利用字典创建Series
dict = {'c':1, 'a':2, 'b':3.14}
s1 = pd.Series(dict)
s2 = pd.Series([6,3,9],index=['b','c','a'])

#可以看到两个Series对象索引都是'a','b','c',但是对应顺序不一致，那么这两个运算结果会如何呢？

print(s1+s2)
'''
a    11.00
b     9.14
c     4.00
dtype: float64
'''
print(s1*s2)
'''
a    18.00
b    18.84
c     3.00
dtype: float64
'''

'''
很显然可以看到就算顺序不同，Series也会自己找到对应的索引，在相同索引自己进行运算，这是Serier的一个重点
'''

import pandas as pd

#当两个Series对象有各自独有的索引时
s1 = pd.Series([1,7,5],index=['c','d','a'])
s2 = pd.Series([6,3,9],index=['b','c','a'])

print(s1+s2)
'''
a    14.0
b     NaN
c     4.0
d     NaN
dtype: float64
'''
print(s1*s2)
'''
a    45.0
b     NaN
c     3.0
d     NaN
dtype: float64
'''

'''
可以看到，s1和s2中，只有'a','c'是共有索引，所以只有这两个索引所指向的元素支持运算
而索引'b','d'分别是s2和s1独有的索引，所以无法参与运算，返回一个NaN(Not a Number)
'''

三、DataFrame

DataFrame是一个表格型的数据结构，类似于Excel或SQL表，所以在项目实践中，excel文件就经常导入为DataFrame类型，以便于数据处理和使用。对于Pandas而言，DataFrame是其最重要的数据结构，也是使用最为频繁的数据结构。

import pandas as pd

#使用列表生成DataFrame
data = [[1,2,3],[4,5,6]]
index = ['a','b']
columns = ['A','B','C']
df = pd.DataFrame(data=data,index=index,columns = columns)
print(df)
'''
   A  B  C
a  1  2  3
b  4  5  6
'''

#使用字典生成DataFrame
df = pd.DataFrame({'姓名':['张三','李四','王梅'],'年龄':['21','23','22'],'性别':['男','男','女']})
print(df)
'''
   姓名  年龄 性别
0  张三  21  男
1  李四  23  男
2  王梅  22  女
'''

#可以看到一个简单的二维表格已经打印出来了，未指定索引时，默认索引从0开始

#取出某一列
print(df['姓名'])
'''
0    张三
1    李四
2    王梅
Name: 姓名, dtype: object
'''

下面讲讲用 Series字典生成 DataFrame以及DataFrame的基本操作，具体如下

import numpy as np
import pandas as pd

#用 Series字典生成 DataFrame
dict = {'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(dict)
print(df)
'''
   one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
d  NaN  4.0

容易看出，'one'列有3个数据，'two'列有4个数据，形成DataFrame时，索引取两者并集，没有对应元素的取值依然为NaN
'''

#取对应列进行列间运算
df['one'] += df['two']
print(df)
'''
   one  two
a  2.0  1.0
b  4.0  2.0
c  6.0  3.0
d  NaN  4.0

可以看到，运算完，'one'所在列已经变为原来的'one'和'two'所在列的值相加，这就是DataFrame的简单列间运算
'''

df['two'] += np.ones(4)
print(df)
'''
   one  two
a  2.0  2.0
b  4.0  3.0
c  6.0  4.0
d  NaN  5.0

可以看到，运算完，'two'所在列已经变为原来的two'所在列的值分别加一，这就是DataFrame如何给一个列加一个数
'''

df['one'] = 0.
print(df)
'''
   one  two
a  0.0  2.0
b  0.0  3.0
c  0.0  4.0
d  0.0  5.0

可以看到，运算完，'one'所在列已经变为'0.0'，这就是DataFrame如何给一整个列赋值
'''

下面讲讲DataFrame的合并，具体如下

import pandas as pd

df1 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                      'A': ['A0', 'A1', 'A2', 'A3'],
                      'B': ['B0', 'B1', 'B2', 'B3']})
df2 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})
print(df1)
'''
  key   A   B
0  K0  A0  B0
1  K1  A1  B1
2  K2  A2  B2
3  K3  A3  B3
'''
print(df2)
'''
  key   C   D
0  K0  C0  D0
1  K1  C1  D1
2  K2  C2  D2
3  K3  C3  D3
'''
print(pd.merge(df1,df2))
'''
  key   A   B   C   D
0  K0  A0  B0  C0  D0
1  K1  A1  B1  C1  D1
2  K2  A2  B2  C2  D2
3  K3  A3  B3  C3  D3
'''

#可以看到，merge()方法自动寻找了相同列索引，然后基于相同列索引进行合并，那么如果找不到相同的列索性呢？

#更改df1的'K3'为'K4'
df1['key'][3]='K4'
print(df1)
'''
  key   A   B
0  K0  A0  B0
1  K1  A1  B1
2  K2  A2  B2
3  K4  A3  B3
'''
print(pd.merge(df1,df2))
'''
  key   A   B   C   D
0  K0  A0  B0  C0  D0
1  K1  A1  B1  C1  D1
2  K2  A2  B2  C2  D2
'''

#可以看到它只合并了有相同索引的行，而找不到对应索引的行就被丢弃掉了。那么如果我想显示所有元素呢？

print(pd.merge(df1,df2,on=['key'],how='outer')) #on=[]用于指定合并的索引，how='outer'用于显示所有元素
'''
  key    A    B    C    D
0  K0   A0   B0   C0   D0
1  K1   A1   B1   C1   D1
2  K2   A2   B2   C2   D2
3  K4   A3   B3  NaN  NaN
4  K3  NaN  NaN   C3   D3
'''

四、通过泰坦尼克号数据集来详细讲解Pandas的使用

首先讲解如何读入csv文件并转化为DataFrame格式，然后讲讲如何查看数据的基本信息，具体如下

import pandas as pd

#读入数据集保存为DataFrame结构
df = pd.read_csv("titanic.csv")

#来看看这个数据集的基本信息
df.info()
'''
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
PassengerId    891 non-null int64
Survived       891 non-null int64
Pclass         891 non-null int64
Name           891 non-null object
Sex            891 non-null object
Age            714 non-null float64
SibSp          891 non-null int64
Parch          891 non-null int64
Ticket         891 non-null object
Fare           891 non-null float64
Cabin          204 non-null object
Embarked       889 non-null object
dtypes: float64(2), int64(5), object(5)
memory usage: 83.6+ KB

可以看到这个数据集有891个记录（行），有12个属性（列），'Age'、'Cabin'和'Embarked'所在列存在数据丢失
'''

#打印前面几行
print(df.head()) #默认是5行，也可以自己在head()里面指定行数
'''
   PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
0            1         0       3  ...   7.2500   NaN         S
1            2         1       1  ...  71.2833   C85         C
2            3         1       3  ...   7.9250   NaN         S
3            4         1       1  ...  53.1000  C123         S
4            5         0       3  ...   8.0500   NaN         S

[5 rows x 12 columns]
'''

那么怎么获取DataFrame中的行列数据呢？具体如下

import pandas as pd

#读入数据集保存为DataFrame结构
df = pd.read_csv("titanic.csv")

#获取列名
print(df.columns)
'''
Index(['PassengerId', 'Survived', 'Pclass', 'Name', 'Sex', 'Age', 'SibSp',
       'Parch', 'Ticket', 'Fare', 'Cabin', 'Embarked'],
      dtype='object')
'''

#获取每行的值
print(df.values[:3]) #数据太多，只输出前三行，每行作为一个元素装入list之中
'''
[[1 0 3 'Braund, Mr. Owen Harris' 'male' 22.0 1 0 'A/5 21171' 7.25 nan 'S']
 [2 1 1 'Cumings, Mrs. John Bradley (Florence Briggs)' 'female' 38.0 1 0 'PC 17599' 71.2833 'C85' 'C']
 [3 1 3 'Heikkinen, Miss. Laina' 'female' 26.0 0 0 'STON/O2. 3101282'7.925 nan 'S']]
'''

#取出数据的某一列
sex = df['Sex']
print(sex[:5]) #数量太多，只读取前五条
'''
0      male
1    female
2    female
3    female
4      male
Name: Sex, dtype: object
'''

#有了性别这一列数据，我们就很容易知道泰坦尼克号上的男女占比了
mnum = fnum =0
for i in range(len(sex)):
    if sex[i] == 'male':
        mnum +=1
    else:
        fnum +=1

#男性占比
print(format(mnum/len(sex),'.0%')) #打印 65%
#女性占比
print(format(fnum/len(sex),'.0%')) #打印 35%

#那么要获取指定列呢？
tempdata = df[['Name', 'Sex', 'Age']]
print(tempdata[:5]) #数据太多，只打印前5行
'''
                                                Name     Sex   Age
0                            Braund, Mr. Owen Harris    male  22.0
1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0
2                             Heikkinen, Miss. Laina  female  26.0
3       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0
4                           Allen, Mr. William Henry    male  35.0
'''

下面讲讲如何使用 ‘iloc’ 获取数据。 ‘iloc’ 用position来定位，即通过数据的行列获取数据，具体如下

import pandas as pd

#读入数据集保存为DataFrame结构
df = pd.read_csv("titanic.csv")

#使用iloc定位
print(df.iloc[2]) #输出第3行乘客的详细信息
'''
PassengerId                         3
Survived                            1
Pclass                              3
Name           Heikkinen, Miss. Laina
Sex                            female
Age                                26
SibSp                               0
Parch                               0
Ticket               STON/O2. 3101282
Fare                            7.925
Cabin                             NaN
Embarked                            S
Name: 2, dtype: object
'''

print(df.iloc[6:9,3:6]) #获取第7、8、9号乘客(乘客从0开始计算)的第4、5、6列属性（Name、Sex、Age）
'''
                                                Name     Sex   Age
6                            McCarthy, Mr. Timothy J    male  54.0
7                     Palsson, Master. Gosta Leonard    male   2.0
8  Johnson, Mrs. Oscar W (Elisabeth Vilhelmina Berg)  female  27.0
'''

下面讲讲如何使用 ‘loc’ 获取数据。 ‘loc’ 用用label来定位，即通过数据的标签获取数据

import pandas as pd

#读入数据集保存为DataFrame结构
df = pd.read_csv("titanic.csv")

#重新定义DataFrame的索引
df = df.set_index('Name') #必须是数据中存在的列名
print(df[:3]) #现在看看前三行数据格式,显然索引变成了‘Name’,而列的数目减一了
'''
                                                    PassengerId  ...  Embarked
Name                                                             ...          
Braund, Mr. Owen Harris                                       1  ...         S
Cumings, Mrs. John Bradley (Florence Briggs Tha...            2  ...         C
Heikkinen, Miss. Laina                                        3  ...         S

[3 rows x 11 columns]
'''

#使用loc定位
print(df.loc['Braund, Mr. Owen Harris'])
'''
PassengerId            1
Survived               0
Pclass                 3
Sex                 male
Age                   22
SibSp                  1
Parch                  0
Ticket         A/5 21171
Fare                7.25
Cabin                NaN
Embarked               S
Name: Braund, Mr. Owen Harris, dtype: object
'''

#获取男性的平均年龄
print(df.loc[df['Sex'] == 'male','Age'].mean()) #打印 30.72664459161148

下面讲讲groupy的简单使用，具体如下

import pandas as pd

#读入数据集保存为DataFrame结构
df = pd.read_csv("titanic.csv")

#查看年龄在18-20的人数
print(df.groupby(['Age']).count()[18:20])
'''
      PassengerId  Survived  Pclass  Name  ...  Ticket  Fare  Cabin  Embarked
Age                                        ...                               
18.0           26        26      26    26  ...      26    26      4        26
19.0           25        25      25    25  ...      25    25      6        25
20.0           15        15      15    15  ...      15    15      0        15

[3 rows x 11 columns]

可以看到18岁的有26人，19岁的有25人，20岁的有15人
'''

#男性和女性的平均年龄
print(df.groupby('Sex')['Age'].mean())
'''
Sex
female    27.915709
male      30.726645
Name: Age, dtype: float64
'''

#男性和女性的获救率
print(df.groupby('Sex')['Survived'].mean())
'''
Sex
female    0.742038
male      0.188908
Name: Survived, dtype: float64
'''