数据分析——pandas

pandas核心数据结构

Series：一维数据

创建Series

1、利用列表创建Series

import pandas as pd
import numpy as np
s1 = pd.Series([1,2,'a',4])

2、创建一个具有标签索引的Series

s2 = pd.Series([1,2,3], index = ['a', 'b', 'c'])

3、利用python字典创建Series

sdata = {'a':1, 'b':2, 'c':3}
s3 = pd.Series(sdata)

Series的索引

类似python的字典根据标签索引查询数据

s2['a']
type(s2['a'])
s2[['b', 'a']]
type(s2[['b', 'a']])

DataFrame：二维数组

DataFrame是一个表格型的数据结构，每列可以是不同的值类型（数值，字符串，布尔值等），既可以有行索引index，也可以有列索引columns，可看成由Series组成的字典

DataFrame的创建

1、根据多个字典序列创建

data = {
			'state':['Ohio','Ohio','Nevada'],
			'year':[2000, 2001, 2002],
			'pop': [1.5, 1.7, 3.6]
}
df = pd.DataFrame(data)
df.types
df.columns
df.index

2、从结构化数据中创建

data = [(1, 2.2, 'Hello'), (2, 3., "World")]
pd.DataFrame(data)
pd.DataFrame(data, index=['first', 'second'], columns=['A', 'B', 'C'])

DataFrame的索引

# 查询一列， 结果是一个pd.Series
df['year']
# 查询多列，结果是一个pd.DataFrame
df[['year', 'pop']]

# 查询一行，结果是一个pd.Series
df.loc[1]
df.loc[1:3]

pandas查询数据

1、使用单个label值查询数据

# 得到单个值
df.loc[1,'year']
# 得到一个Series
df.loc[1, ['year', 'pop']]

2、使用值列表批量查询

# 得到DataFrame
df.loc[[1,2], ['year', 'pop']]

3、使用数值区间进行范围查询

df.loc[1:2, 'year':'pop']

4、使用条件表达式查询

df.loc[df['pop']<2, :]
df.loc[(df['pop']<2) & (df['year']<2002), :]

5、调用函数查询

df.loc[lambda df: (df['pop']<2) & (df['year']<2002), :]

pandas新增/删除数据列

pandas新增数据列

1、直接赋值的方法

# 新增一列'tem'
df.loc[:, 'tem'] = 3
# 指定插入位置
df.insert(1, 'bar', df['state'])

2、df.apply方法

def f(x):
	return 2*x['pop']
# axis = 1意味着将列传入，axis = 0意味着将行传入
df.loc[:, 'tem'] = df.apply(f, axis = 1)
# 查看计数
df['tem'].value_counts()

3、df.assign方法

df.assign(
	'temp' = lambda x: x['pop']*3
	'temp_2' = lambda x: x['year'] + 1
)

4、按照条件选择分组分别赋值

# 先建一个空列
df['newcol'] = ''
df.loc[df['temp']-df['tem']>1, 'newcol'] = 'good'
df.loc[df['temp']-df['tem']<=1, 'newcol'] = 'great'

pandas删除数据列

del df['tem']
tem = df.pop('tem')

pandas数据统计函数

1、汇总类统计
describe()函数

# 提取所有数字列统计结果
df.describe()

mean, min, max函数

# 查看单个Series的数据
df['tem'].mean()
df['tem'].min()
df['tem'].max()

2、唯一去重和按值计算

# 一般用于枚举、分类列
df['state'].unique()
# 按值计数 
df['state'].value_counts()
# 判断索引是否唯一
df.index.is_unique 
df.isin([列表])

3、相关系数和协方差

# 协方差矩阵
df.cov()
# 相关系数矩阵
df.corr()
# 单独查看二者的相关系数
df['pop'].corr(df['tem'])

pandas处理缺失值

pandas使用以下函数处理缺失值

isnull, notnull: 检测是否是空值，可用于 DataFrame 和Series.
dropna: 丢弃、删除缺失值，有3个参数
a. axis: 删除行/列 {0 or ‘index’, 1 or ‘columns’}, default 0
b. how: 如何等于any则任何值为空都删除，如果等于all则所有值为空才删除
c. inplace: 如果为True则修改当前df, 否则返回一个新的df
fillna: 填充空值，有4个参数
a. value: 用于填充的值，可为单个值，或者字典（key是列名，value是值）
b. method: 等于ffill使用前一个不为空的值填充；等于bfill使用后一个不为空的值填充
c. axis: 按行还是列填充，{0 or ‘index’, 1 or ‘columns’}
d. inplace: 如果为True则修改当前df, 否则返回一个新的df

df.isnull() # df.notnull()
# 或者
df[''].isnull()
# 删掉掉全为空值的列/行
df.dropna(axis = 'columns'/'index', how = 'all', inplace = True)  # 只有这一列全为空值时才删除
# 将某一列的空值填充为0
df.fillna({'key'(列名): 0(填充值)})
# 或者
df.loc[:, '列名'] = df['列名'].fillna(0)
# 使用前面的不为空值填充
df.loc[:, '列名'] = df['列名'].fillna(method = 'ffill')

pandas数据排序

Series的排序

Series.sort_values(ascending = True, inplace = False)
说明: ascending: 默认为True升序排序，为False降序排序

DateFrame的排序

DateFrame.sort_values(by, ascending = True, inplace = False)
说明:
by：字符串或者列表<字符串>，来决定是单列排序或者多列排序
ascending: bool或者list，若是list则与by对应

pandas索引

1、index查询数据

# set_index是创造索引，drop = False让索引列仍保留再column中 
df.set_index('index名', inplace = True, drop = False)
# 使用column的condition查询方法，以下两个效果相同
df.loc[3]
df.loc[df['index_name'] == 3]

2、对索引交换及排序

# 单层索引的排序
df.sort_index()
# 多层索引的排序
df = pd.DataFrame(np.random.randint(1, 10, (4, 3)), 
                  index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]], 
                  columns=[['one', 'one', 'two'], ['blue', 'red', 'blue']])
df.index.names = ['row-1', 'row-2']
df.columns.names = ['col-1', 'col-2']
# 交换索引
df2 = df.swaplevel('row-1', 'row-2')
# 对第一层索引排序
df2.sortlevel(0)

3、index能自动对齐数据

s1 = pd.Series([1,2,3], index = list('abc'))
s2 = pd.Series([2,3,4], index = list('bcd'))
s1+s2
# 输出结果
a  NaN
b  4.0
c  6.0
d  NaN
dtype: float64

pandas分组计算

df = pd.DataFrame({'key1': ['a', 'a', 'b', 'b', 'a'],
                  'key2': ['one', 'two', 'one', 'two', 'one'],
                  'data1': np.random.randint(1, 10, 5),
                  'data2': np.random.randint(1, 10, 5)})
df
Out[57]: 
   key1 key2  data1  data2
0    a  one      1      5
1    a  two      5      7
2    b  one      5      8
3    b  two      1      4
4    a  one      7      5

利用groupby对单个列进行分组计算

df.groupby('key1').sum()
Out[58]: 
      data1  data2
key1              
a        13     17
b         6     12
# 看到将'key1'变成看索引列，且因为要统计sum，但'key2'不是数字，所以自动忽略
# 给 df 每行都添加一个以 key1 分组后的平均值
k1_mean = df.groupby('key1').mean().add_prefix('mean_')
k1_mean
Out: 
      mean_data1  mean_data2
key1                        
a       4.333333    5.666667
b       3.000000    6.000000

利用groupby对多个列进行分组计算

df.groupby(['key1', 'key2']).mean()  
Out[61]: 
           data1  data2
key1 key2              
a    one       4      5
     two       5      7
b    one       5      8
     two       1      4

# 看到('key1','key2')变成了索引，而df.groupby(['key1', 'key2'], as_index = False).mean()时('key1','key2')就不会变成索引。

# 每个分组的元素个数
df.groupby(['key1', 'key2']).size()
Out[62]: 
key1  key2
a     one     2
      two     1
b     one     1
      two     1
# 对分组进行遍历
for name, group in df.groupby('key1'):
    print name
    print group
# 输出
a
  key1 key2  data1  data2
0    a  one      1      5
1    a  two      5      7
4    a  one      7      5
b
  key1 key2  data1  data2
2    b  one      5      8
3    b  two      1      4
# 获取单个分组的数据
df.groupby('key1').get_group('a')
Out[83]: 
  key1 key2  data1  data2
0    a  one      1      5
1    a  two      5      7
4    a  one      7      5

利用agg同时查看多种数据统计

df.groupby('key1').agg(np.sum, np.mean, np.std)
Out[68]: 
       data1                     data2                    
       sum      mean       std   sum      mean       std
key1                                                    
a       13  4.333333  3.055050    17  5.666667  1.154701
b        6  3.000000  2.828427    12  6.000000  2.828427
# 看到列变成了多级索引
# 查看单列的结果数据统计
# 法一
df.groupby('key1')['data1'].agg([np.sum, np.mean, np.std])
# 法二
df.groupby('key1').agg([np.sum, np.mean, np.std])['data1']
Out[72]: 
      sum      mean       std
key1                         
a      13  4.333333  3.055050
b       6  3.000000  2.82842

# 不同列使用不同聚合函数
df.groupby('key1').agg({'data1': np.sum, 'data2': np.mean})
Out[73]: 
      data1     data2
key1                 
a        13  5.666667
b         6  6.000000

pandas实现数据的Merge

merge语法
pd.merge(left, right, how = ‘inner’, on = None, left_on = None, right_on = None, left_index = False, right_index = False, sort = True, suffixes = (’_x’, ‘_y’), copy = True, indicator = False, validate = None)

a. left, right: 要merge的dataframe或有name的Series
b. how: join类型，‘left’, ‘right’, ‘inner’, ‘outer’
c. on: join的key, left和right都需要有这个key
d. left_on: left的df或者series的key
e. right_on: right的df或者series的key
f. left_index , right_index: 使用index而不是普通的columns做join
g. suffixes: 两个元素的后缀，如果列有重名，自动添加后缀，默认为(’_x’, ‘_y’)

Pandas载入数据

pandas需要先读取表格类型的数据，然后进行分析

数据类型	说明	Pandas读取方法
csv、tsv、 txt	用逗号分隔、tab分割的纯文本文件	pd.read_csv
excel	微软xls或者xlsx文件	pd.read_excel
mysql	关系型数据库表	pd.read_sql

import pandas as pd
# 读取csv文件
df = pd.read_csv('data/ex1.csv')
# 读取txt文件，自己指定分隔符、列名
df = pd.read_csv(
			'data/ex1.csv', 
			sep=','
			header = None
			names = ['自己设置列名']
			)
# 读取excel文件
df = pd.read_excel('data/ex1.csv')

# 保持数据到磁盘
df = pd.read_csv('data/ex5.csv')
df.to_csv('data/ex5_out.csv')