一个强大的分析结构化数据的工具集
基础是NumPy，提供了高性能矩阵的运算
pandas 数据结构
Series
类似一维数组的对象
通过list构建Series
ser_obj = pd.Series(range(10))
# 通过list构建Series
ser_obj = pd.Series(range(10, 20))
print(type(ser_obj))获取数据和索引
ser_obj.index, ser_obj.values
# 获取数据
print(ser_obj.values)
# 获取索引
print(ser_obj.index)预览数据
ser_obj.head(n)
通过索引获取数据
ser_obj[idx]
索引与数据的对应关系仍保持在数组运算的结果中
#通过索引获取数据
print(ser_obj[0])
print(ser_obj[8])
# 索引与数据的对应关系仍保持在数组运算的结果中
print(ser_obj * 2)
print(ser_obj > 15)
"""
0 20
1 22
2 24
3 26
4 28
5 30
6 32
7 34
8 36
9 38
dtype: int64
0 False
1 False
2 False
3 False
4 False
5 False
6 True
7 True
8 True
9 True
dtype: bool
"""通过dict构建Series
# 通过dict构建Series
year_data = {2001: 17.8, 2002: 20.1, 2003: 16.5}
ser_obj2 = pd.Series(year_data)
print(ser_obj2.head())
print(ser_obj2.index)
"""
2001 17.8
2002 20.1
2003 16.5
dtype: float64
Int64Index([2001, 2002, 2003], dtype='int64')
"""name属性
ser_obj.name, ser_obj.index.name
# name属性
ser_obj2.name = 'temp'
ser_obj2.index.name = 'year'
print(ser_obj2.head())
"""
year
2001 17.8
2002 20.1
2003 16.5
Name: temp, dtype: float64
"""DataFrame
类似多维数组/表格数据 (如，excel, R中的data.frame)
每列数据可以是不同的类型
索引包括列索引和行索引
通过ndarray构建DataFrame
import numpy as np
# 通过ndarray构建DataFrame
array = np.random.randn(5,4)
print(array)
"""
[[ 0.24080667 -0.52446211 -2.00060545 1.58069728]
[-0.25096401 0.18001484 -0.66252232 0.20919581]
[ 1.06301792 0.25150653 -0.67519772 -1.16752965]
[-0.61844643 0.60141776 -0.11604881 1.05742347]
[-0.63934044 -0.52350101 0.13534844 0.77631123]]
"""
df_obj = pd.DataFrame(array)
print(df_obj.head())通过dict构建DataFrame
# 通过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,dtype='int32'),
'E' : pd.Categorical(["Python","Java","C++","C#"]),
'F' : 'ChinaHadoop' }
print (dict_data) #无序
df_obj2 = pd.DataFrame(dict_data)
print(df_obj2.head())
"""
A B C D E F
0 1.0 2016-12-17 1.0 3 Python ChinaHadoop
1 1.0 2016-12-17 1.0 3 Java ChinaHadoop
2 1.0 2016-12-17 1.0 3 C++ ChinaHadoop
3 1.0 2016-12-17 1.0 3 C# ChinaHadoop
"""通过列索引获取列数据(Series类型 )
df_obj[col_idx] 或 df_obj.col_idx
# 通过列索引获取列数据
print(df_obj2['A'])
print(type(df_obj2['A'])) #<class 'pandas.core.series.Series'>
print(df_obj2.A)增加列数据，类似dict添加key-value
df_obj[new_col_idx] = data
# 增加列
df_obj2['G'] = df_obj2['D'] + 4
print(df_obj2.head())删除列
del df_obj[col_idx]
# 删除列
del(df_obj2['G'] )
print(df_obj2.head())索引对象Index
Series和DataFrame中的索引都是Index对象 不可变(immutable 保证了数据的安全)
常见的Index种类
• Index
• Int64Index
• MultiIndex，“层级”索引
• DatetimeIndex，时间戳类型print(type(ser_obj.index))
print(type(df_obj2.index))
print(df_obj2.index)
"""
<class 'pandas.indexes.range.RangeIndex'>
<class 'pandas.indexes.numeric.Int64Index'>
Int64Index([0, 1, 2, 3], dtype='int64')
"""
# 索引对象不可变
df_obj2.index[0] = 2 #报错Pandas的数据操作
索引操作
Series索引操作
行索引，ser_obj[‘label’], ser_obj[pos]
切片索引，ser_obj[2:4], ser_obj[‘label1’: ’label3’]
# 切片索引
print(ser_obj[1:3])
print(ser_obj['b':'d']) #含 d不连续索引，ser_obj[[‘label1’, ’label2’, ‘label3’]]
ser_obj[[pos1, pos2, pos3]]
# 不连续索引
print(ser_obj[[0, 2, 4]])
print(ser_obj[['a', 'e']])布尔索引
ser_obj = pd.Series(range(5), index = ['a', 'b', 'c', 'd', 'e'])
print(ser_obj.head())
# 布尔索引
ser_bool = ser_obj > 2
print(ser_bool)
print(ser_obj[ser_bool])
print(ser_obj[ser_obj > 2])
"""
a False
b False
c False
d True
e True
dtype: bool
d 3
e 4
dtype: int64
d 3
e 4
dtype: int64
"""DataFrame索引操作
列索引 df_obj[‘label’]
不连续索引 df_obj[[‘label1’, ‘label2’]]
# 列索引
print('列索引')
print(df_obj['a']) # 返回Series类型
print(type(df_obj[[0]])) # 返回DataFrame类型 #df_obj[['a']]
# 不连续索引
print('不连续索引')
print(df_obj[['a','c']])
print(df_obj[[1, 3]])Pandas的索引操作
可归纳为3种
.loc，标签索引
.iloc，位置索引
.ix，标签与位置混合索引(先按标签索引尝试操作，然后再按位置索引尝试操作)
DataFrame索引时可将其看作ndarray操作
• 标签的切片索引是包含末尾位置的
# DataFrame
print(df_obj['a'])
print(df_obj.loc[0:2, 'a'])#标签的切片索引是包含末尾位置的
"""
0 -0.236778
1 0.045082
2 -1.522824
3 1.232838
4 1.054741
Name: a, dtype: float64
0 -0.236778
1 0.045082
2 -1.522824
Name: a, dtype: float64
"""# 整型位置索引 iloc
print(ser_obj[1:3]) #不含 ]
print(ser_obj.iloc[1:3])
# DataFrame
print(df_obj.iloc[0:2, 0])# 位置索引 0:2 不含2
# 注意和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]) # 先按标签索引尝试操作，然后再按位置索引尝试操作
"""
0 -0.236778
1 0.045082
2 -1.522824
Name: a, dtype: float64
"""运算与对齐
索引对齐运算，没对齐的位置补NaN
Series 按行索引对齐
DataFrame按行、列索引对齐
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)
"""
df1:
a b
0 1.0 1.0
1 1.0 1.0
df2:
a b c
0 1.0 1.0 1.0
1 1.0 1.0 1.0
2 1.0 1.0 1.0
"""
填充未对齐的数据进行运算
使用add, sub, div, mul
同时通过fill_value指定填充值
填充NaN
df3 = df1 + df2
print(df3)
"""
a b c
0 2.0 2.0 NaN
1 2.0 2.0 NaN
2 NaN NaN NaN
"""
df3.fillna(100, inplace = True)
print(df3)
"""
a b c
0 2.0 2.0 100.0
1 2.0 2.0 100.0
2 100.0 100.0 100.0
"""函数应用
# 使用apply应用行或列数据
#f = lambda x : x.max()
print(df.apply(lambda x : x.max()))
"""
0 0.149288
1 0.211810
2 0.725562
3 -0.223388
dtype: float64
"""
# 指定轴方向 行
print(df.apply(lambda x : x.max(), axis=1))
"""
0 0.725562
1 -0.423329
2 0.242500
3 -0.223388
4 -0.236904
dtype: float64
"""
使用applymap应用到每个数据
f2 = lambda x : '%.2f' % x
print(df.applymap(f2))
"""
0 1 2 3
0 -2.35 -1.36 0.73 -0.91
1 -2.37 -1.35 -0.59 -0.42
2 0.15 0.21 0.24 -0.68
3 -2.88 -1.44 -0.92 -0.22
4 -0.69 -0.24 -1.12 -1.17
"""排序
sort_index，索引排序
(对DataFrame操作时注意轴方向)
按值排序
sort_values(by=‘label’)
处理缺失数据
判断是否存在缺失值
ser_obj.isnull(), df_obj.isnull()
dropna 丢弃缺失数据
fillna 填充缺失数据
