python之pandas

import pandas as pd

#Series:一维数组

#通过list来创建序列

ser_obj=pd.Series(range(10,20));print(type(ser_obj));print(ser_obj.values);print(ser_obj.index)#获取数据；获取索引

ser_obj.head(3)#默认预览数据前5行

通过索引获取数据     ser_obj[0]#获取第一个

索引与数据的对应关系仍保持在数组运算的结果中    print(ser_obj[ser_obj>15])#数据筛选

通过dict来创建序列  year_data={2001:17,2002:20,2003:16};ser_obj2=pd.Series(year_data);

对整个序列和索引列取名字   ser_obj2.name='temp';ser_obj2.index.name='year'

DataFrame #多维数组、表格数据 ，每列可以使不同的类型，索引包括列索引和行索引

通过ndarray来创建DataFrame       import numpy as np; array=np.random.randn(5,4);df_obj=pd.DataFrame(array)

通过dict来创建DataFrame          

dict_data={'a':1,'b':pd.Timestamp('20161217'),

                'c':pd.Series(1,index=list(range(4)),dtype='float32','d':np.array([3]*4),

                  'e':pd.Categorical(['c','vb']), 'f':'qiqi'};df_obj2=pd.DataFrame(dict_data)

优先通过列索引获取列数据    print(df_obj2)

import pandas as pd
ser_obj = pd.Series(range(5), index = ['a', 'b', 'c', 'd', 'e'])
# 行索引
print(ser_obj['a'])
print(ser_obj[3])
# 切片索引
print(ser_obj[1:3])#用位置索引，不包含最后的值
print(ser_obj['b':'d'])#用名称索引，包含最后的值
# 不连续索引
print(ser_obj[[0, 2, 4]])
print(ser_obj[['a', 'e']])#两个中括号，即里面放了个列表
# 布尔索引
ser_bool = ser_obj > 2
print(ser_bool)
print(ser_obj[ser_bool])
# 标签索引 loc
print(ser_obj['b':'d'])
print(ser_obj.loc['b':'d'])
import numpy as np


df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])
# 列索引
print('列索引')
print(df_obj['a']) # 返回Series类型,取列
print(df_obj.loc[[0]]) # 返回DataFrame类型#两个中括号，取行


# 不连续索引.loc
print('不连续索引')
print(df_obj[[]])
print(df_obj.loc[[1,3]]) # 返回DataFrame类型#两个中括号，取行
# 标签索引 loc
# DataFrame
print(df_obj['a'])
print(df_obj.loc[0:2, 'a'])
# 整型位置索引 iloc
print(ser_obj[1:3])
print(ser_obj.iloc[1:3])


# DataFrame
print(df_obj.iloc[0:2, 0]) # 注意和df_obj.loc[0:2, 'a']的区别
 混合索引 ix
print(ser_obj.ix[1:3])
print(ser_obj.ix['b':'c'])


# DataFrame
print(df_obj.ix[0:2, 0]) # 先按标签索引尝试操作，然后再按位置索引尝试操作
#填充缺失值
s3_filled = s3.fillna(-1)
print(s3_filled)
df3.fillna(100, inplace = True)
print(df3)
# 使用applymap应用到每个数据
f2 = lambda x : '%.2f' % x
print(df.applymap(f2))#将f2函数传进去
## 使用apply应用行或列数据
print(df.apply(lambda x : x.max()))#默认按列
axis=1表示按行，axis=0表示按列
print(df.apply(lambda x : x.max(), axis=1))#axis=1表示按行
#排序
df4.sort_index(axis=1)#列索引递增
#df4.sort_index(axis=0)#行索引递增
#处理缺失数据
df_data = pd.DataFrame([np.random.randn(3), [1., np.nan, np.nan],
                       [4., np.nan, np.nan], [1., np.nan, 2.]])
df_data.head()
df_data.isnull()#判断是否是缺失
df_data.dropna()#去掉所有缺失值
df_data.dropna(axis=1)#保留完整的列
# fillna

df_data.fillna(-100.)#填充缺失

统计描述

df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])

df_obj

df_obj.sum()#默认按列
df_obj.max()

df_obj.min(axis=1)#按行

df_obj.describe()

层级索引

ser_obj = pd.Series(np.random.randn(12),
                    index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                           [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]])
print(ser_obj)

# 外层选取
print(ser_obj['c'])
# 内层选取

print(ser_obj[:, 2])

print(ser_obj.swaplevel())#交换分层

print(ser_obj.swaplevel().sortlevel())#交换分层并排序

groupby函数

# dataframe根据key1进行分组

print(type(df_obj.groupby('key1')))
# data1列根据key1进行分组

print(type(df_obj['data1'].groupby(df_obj['key1'])))

# 分组运算
grouped1 = df_obj.groupby('key1')
print(grouped1.mean())
grouped2 = df_obj['data1'].groupby(df_obj['key1'])

print(grouped2.mean())

# size
print(grouped1.size())

print(grouped2.size())

merge函数

# on显示指定“外键”

pd.merge(df_obj1, df_obj2, on='key')

# left_on，right_on分别指定左侧数据和右侧数据的“外键”

pd.merge(df_obj1, df_obj2, left_on='key1', right_on='key2')

# “外连接”
pd.merge(df_obj1, df_obj2, left_on='key1', right_on='key2', how='outer')


# 更改列名
df_obj1 = df_obj1.rename(columns={'key':'key1'})

df_obj2 = df_obj2.rename(columns={'key':'key2'})

pd.merge(df_obj1, df_obj2, left_on='key1', right_on='key2')

# “外连接”
pd.merge(df_obj1, df_obj2, left_on='key1', right_on='key2', how='outer')
# 左连接

pd.merge(df_obj1, df_obj2, left_on='key1', right_on='key2', how='left')

# 右连接

pd.merge(df_obj1, df_obj2, left_on='key1', right_on='key2', how='right')

# 处理重复列名
df_obj1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
                        'data' : np.random.randint(0,10,7)})
df_obj2 = pd.DataFrame({'key': ['a', 'b', 'd'],
                        'data' : np.random.randint(0,10,3)})

pd.merge(df_obj1, df_obj2, on='key', suffixes=('_left', '_right'))

import numpy as np
import pandas as pd
# 按索引连接
df_obj1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
                        'data1' : np.random.randint(0,10,7)})
print(df_obj1)
df_obj2 = pd.DataFrame({'data2' : np.random.randint(0,10,3)}, index=['a', 'b', 'd'])

print(df_obj2)

pd.merge(df_obj1, df_obj2, left_on='key',right_index=True)

concat函数

np.concatenate([arr1, arr2])

np.concatenate([arr1, arr2], axis=1)

数据重构

df_obj = pd.DataFrame(np.random.randint(0,10, (5,2)), columns=['data1', 'data2'])

df_obj

stacked = df_obj.stack()

print(stacked)

# 默认操作内层索引
stacked.unstack()
# 通过level指定操作索引的级别

stacked.unstack(level=0)

去重复数据

df_obj = pd.DataFrame({'data1' : ['a'] * 4 + ['b'] * 4,
                       'data2' : np.random.randint(0, 4, 8)})
df_obj

df_obj.duplicated()

df_obj.drop_duplicates()

df_obj.drop_duplicates('data2')

#map函数对每一个数据进行操作

ser_obj = pd.Series(np.random.randint(0,10,10))

ser_obj

ser_obj.map(lambda x : x ** 2)

数据替换replace

# 替换单个值
ser_obj.replace(0, -100)
# 替换多个值
ser_obj.replace([0, 2], -100)
# 替换多个值
ser_obj.replace([0, 2], [-100, -200])