Pandas

2.数据操作   Series and Dataframe

（1）Series 索引

• 行索引 ser_obj['label'],  ser_obj[position]
• 切片索引
• 不连续索引
• 布尔索引

import pandas as pd
ser_obj = pd.Series(range(5), index = ['a', 'b', 'c', 'd', 'e'])
print(ser_obj.head())

# 行索引
print(ser_obj['a'])
print(ser_obj[0])

# 切片索引
print(ser_obj[1:3])
print(ser_obj['b':'d'])
# print(ser_obj.loc[1:3])
# print(ser_obj.loc['b':'d'])

# 不连续索引
print(ser_obj[[0, 1, 4]])
print(ser_obj[['a', 'e']])


# 布尔索引
ser_bool = ser_obj > 2
print(ser_bool)
print(ser_obj[ser_bool])

print(ser_obj[ser_obj > 2])

（2）Dataframe 索引

• 列索引
• 不连续索引

import numpy as np

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


# 列索引
print('列索引')
print(df_obj['a']) # 返回Series类型

# 不连续索引
# print('不连续索引')
# print(df_obj[['a','c']])
print(df_obj)

（3）series dataframe 3种索引方式

• 标签索引
• 整型位置索引
• 混合索引

# 标签索引 loc
# Series
print(ser_obj)
print(ser_obj['b':'d'])
print(ser_obj.loc['b':'d'])

# 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]) # 先按标签索引尝试操作，然后再按位置索引尝试操作

运算与对齐

• 按索引对齐运算，没对齐的位置补Na
• 填充未对齐的数据进行运算 
  • add,sub,div,mul
  • fill_value
  • 填充NaN   fillna

import numpy as np

df1 = pd.DataFrame(np.ones((2,2)), columns = ['a', 'b'])
df2 = pd.DataFrame(np.ones((3,3)), columns = ['a', 'b', 'c'])

print('df1: ')
print(df1)

print('') 
print('df2: ')
print(df2)


# DataFrame对齐操作
df1 + df2


# 填充未对齐的数据进行运算
print(s1)
print(s2)

s1.add(s2, fill_value = -1)

df1.sub(df2, fill_value = 2.)

# 填充NaN
s3 = s1 + s2
print(s3)


s3_filled = s3.fillna(-1)
print(s3_filled)


df3 = df1 + df2
print(df3)


df3.fillna(100, inplace = True)
print(df3)

函数应用

• apply

# Numpy ufunc 函数
df = pd.DataFrame(np.random.randn(5,4) - 1)
print(df)

print(np.abs(df))


# 使用apply应用行或列数据
#f = lambda x : x.max()
print(df.apply(lambda x : x.max()))

# 指定轴方向
print(df.apply(lambda x : x.max(), axis=1))

# 使用applymap应用到每个数据
f2 = lambda x : '%.2f' % x
print(df.applymap(f2))

• 排序

s4 = pd.Series(range(10, 15), index = np.random.randint(5, size=5))
print(s4)


# 索引排序
s4.sort_index()


df4 = pd.DataFrame(np.random.randn(3, 4), 
                   index=np.random.randint(3, size=3),
                   columns=np.random.randint(4, size=4))
print(df4)


#df4.sort_index(ascending=False)
df4.sort_index(axis=0)


# 按值排序
df4.sort_values(by=2,axis = 1)

• 处理缺失数据

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()


# isnull
df_data.isnull()

# dropna
df_data.dropna()
#df_data.dropna(axis=1)


# fillna
df_data.fillna(-100.)