基本功能
| 属性或方法 |
说明 |
| axes |
返回行轴标签列表 |
| dtype/dtypes |
返回对象的数据类型 |
| empty |
如果系列为空，则返回True |
| ndim |
返回底层数据的维数 |
| size |
元素总数 |
| values |
将系列作为ndarray返回 |
| head() |
返回前n行 |
| tail() |
返回最后n行 |
| T |
转置行和列，适用于DataFrame |
排序
| 函数 |
说明 |
例 |
| sort_index() |
按标签排序。axis参数值为：0纵向、1横向，ascending：True升序，False降序 |
df.sort_index(ascending=False) |
| sort_values() |
按值排序。by：列标签，可以是数组，kind：排序方式 |
df.sort_values(by='a', ascending=True) |
选取数据
| 函数 |
说明 |
例 |
| .loc() |
基于标签，参数可为单个标签、标签列表、切片对象、一个布尔数组 |
df.loc['a':'h',['A','C']] |
| .iloc() |
基于索引，参数可为整数、整数列表、系列值 |
df.iloc[:2,1:3] |
| .ix() |
基于行索引和列标签混合方式 |
df.ix[:2,'a'] |
通过单个标签、标签数组、切片选取数据：
df['A'] # 等同于df.A
df[['A','B']]
df[:2]
处理缺失数据NA
| 函数 |
说明 |
| isnull() |
如果为NA，返回布尔值True，否则为False |
| notnull() |
与isnull()相反 |
| fillna() |
寻找NA值，替换为value，参数method填充方式:pad/ffill向前填充，bfill/backfill向后填充 |
| ffill() |
等同于fillna(method=’ffill’) |
| bfill() |
等同于fillna(method=’bfill’) |
| dropna() |
丢弃包含NA值的行或者列，axis默认为0，即丢弃行 |
| replace() |
替换，用标量值替换NA则等同于 fillna()函数 |
例子
df = pd.DataFrame(np.arange(12).reshape(3,4), index=['first','two','three'], columns=list('abcd'))
df = df.reindex(['first','two','four'])
print(df)
'''
a b c d
first 0.0 1.0 2.0 3.0
two 4.0 5.0 6.0 7.0
four NaN NaN NaN NaN'''
print(df.isnull())
print(df.a.notnull())
'''
a b c d
first False False False False
two False False False False
four True True True True
first True
two True
four False
'''
print(df.loc['four'].sum())
'''0.0'''
data = df.dropna()
print(data)
'''
a b c d
first 0.0 1.0 2.0 3.0
two 4.0 5.0 6.0 7.0'''
data = df.fillna(0)
print(data)
'''
a b c d
first 0.0 1.0 2.0 3.0
two 4.0 5.0 6.0 7.0
four 0.0 0.0 0.0 0.0'''
data = df.fillna(method='ffill')
print(data)
'''
a b c d
first 0.0 1.0 2.0 3.0
two 4.0 5.0 6.0 7.0
four 4.0 5.0 6.0 7.0
'''
data = df.ffill()
print(data)
'''
a b c d
first 0.0 1.0 2.0 3.0
two 4.0 5.0 6.0 7.0
four 4.0 5.0 6.0 7.0
'''
df = df.reindex(['first','four','two'])
print(df)
'''
a b c d
first 0.0 1.0 2.0 3.0
four NaN NaN NaN NaN
two 4.0 5.0 6.0 7.0'''
data = df.replace({np.nan:0,3:33})
print(data)
'''
a b c d
first 0.0 1.0 2.0 33.0
four 0.0 0.0 0.0 0.0
two 4.0 5.0 6.0 7.0'''
分组
| 函数/属性 |
说明 |
| groupby() |
参数key可以是标签或标签数组，axis选择方向 |
| get_group() |
选择分组 |
| agg() |
聚合，参数可以为数组 |
| transform() |
分组或列上的转换返回索引大小与被分组的索引相同的对象，参数为转换函数 |
| filter() |
过滤根据定义的标准过滤数据并返回数据的子集，参数为过滤函数 |
df = pd.DataFrame({
'name':['Tom','Tom','Andy','tony','Andy','Tom','tony'],
'rank':[1,2,3,1,4,3,2],
'year':[2016,2014,2015,2013,2012,2009,2011]
})
print(df)
'''
name rank year
0 Tom 1 2016
1 Tom 2 2014
2 Andy 3 2015
3 tony 1 2013
4 Andy 4 2012
5 Tom 3 2009
6 tony 2 2011'''
grouped = df.groupby(by='name')
print(grouped)
''''''
print(grouped.groups)
'''
{'tony': Int64Index([3, 6], dtype='int64'), 'Andy': Int64Index([2, 4], dtype='int64'), 'Tom': Int64Index([0, 1, 5], dtype='int64')}
'''
print(grouped.get_group('Tom'))
'''
name rank year
0 Tom 1 2016
1 Tom 2 2014
5 Tom 3 2009
'''
for name,values in grouped:
print('{}:'.format(name))
print(values)
'''
Andy:
name rank year
2 Andy 3 2015
4 Andy 4 2012
Tom:
name rank year
0 Tom 1 2016
1 Tom 2 2014
5 Tom 3 2009
tony:
name rank year
3 tony 1 2013
6 tony 2 2011
'''
data = grouped['rank'].agg(np.mean)
print(data)
'''
name
Andy 3.5
Tom 2.0
tony 1.5
Name: rank, dtype: float64'''
data = grouped['rank'].agg([np.sum, np.size, np.mean])
print(data)
'''
sum size mean
name
Andy 7 2 3.5
Tom 6 3 2.0
tony 3 2 1.5
'''
func = lambda x: x**2
data = grouped['rank'].transform(func)
print(data)
'''
0 1
1 4
2 9
3 1
4 16
5 9
6 4
Name: rank, dtype: int64
'''
func = lambda x: len(x)>2
data = grouped['name'].filter(func)
print(data)
'''
0 Tom
1 Tom
5 Tom
Name: name, dtype: object
'''
合并
| 函数 |
说明 |
| merge() |
合并两个DataFrame |
参数：left、right、how、on、left_on、right_on、left_index、right_index、sort
- left : 一个DataFrame对象
- right : 另一个DataFrame对象
- on : 列(名称)连接，必须在左和右DataFrame对象中存在(找到)
- left_on : 来自左侧DataFrame中的列用作键，可以是列名或长度等于DataFrame长度的数组
- right_on : 来自右侧的DataFrame的列作为键，可以是列名或长度等于DataFrame长度的数组
- left_index : 如果为True，则使用左侧DataFrame中的索引(行标签)作为其连接键。 在具有MultiIndex(分层)的DataFrame的情况下，级别的数量必须与来自右DataFrame的连接键的数量相匹配
- right_index : 与右DataFrame的left_index具有相同的用法
- how : 它是left, right, outer以及inner之中的一个，默认为内inner。left：使用左侧对象的键，right： 使用右侧对象的键，outer：使用键的并集，inner：使用键的交集
- sort : 按照字典顺序通过连接键对结果DataFrame进行排序。默认为True，设置为False时，在很多情况下大大提高性能
left = pd.DataFrame({
'name':['Tom','Tim','Marry'],
'age':[10,12,8]
})
right = pd.DataFrame({
'name':['Sum','Andy','Marry'],
'age':[11,9,8]
})
print(left)
print(right)
'''
age name
0 10 Tom
1 12 Tim
2 8 Marry
age name
0 11 Sum
1 9 Andy
2 8 Marry
'''
data = pd.merge(left, right, on=['name','age'])
print(data)
'''
age name
0 8 Marry
'''
data = pd.merge(left, right, on='name', how='outer')
print(data)
'''
age_x name age_y
0 10.0 Tom NaN
1 12.0 Tim NaN
2 8.0 Marry 8.0
3 NaN Sum 11.0
4 NaN Andy 9.0'''
data = pd.merge(left, right, on='name', how='left')
print(data)
'''
age_x name age_y
0 10 Tom NaN
1 12 Tim NaN
2 8 Marry 8.0'''
连接
| 函数 |
说明 |
| concat() |
对象的组合，参数objs:Series，DataFrame或Panel对象的序列，axis：拼接方向，默认0纵向，join：inner交集、默认outer并集，ignore_index：重新建立索引 |
| append() |
对象的纵向组合 |
left = pd.DataFrame({
'name':['Tom','Tim','Marry'],
'age':[10,12,8]
})
right = pd.DataFrame({
'name':['Sum','Andy','Marry'],
'age':[11,9,8]
})
data = pd.concat([left, right])
print(data)
'''
age name
0 10 Tom
1 12 Tim
2 8 Marry
0 11 Sum
1 9 Andy
2 8 Marry
'''
data = pd.concat([left, right], ignore_index=True)
print(data)
'''
age name
0 10 Tom
1 12 Tim
2 8 Marry
3 11 Sum
4 9 Andy
5 8 Marry
'''
data = pd.concat([left, right], axis=1)
print(data)
'''
age name age name
0 10 Tom 11 Sum
1 12 Tim 9 Andy
2 8 Marry 8 Marry
'''
data = left.append(right, ignore_index=True)
print(data)
'''
age name
0 10 Tom
1 12 Tim
2 8 Marry
3 11 Sum
4 9 Andy
5 8 Marry
'''
数据统计函数
| 属性或方法 |
说明 |
| count() |
数量 |
| sum() |
所有值之和 |
| prod() |
数组元素的乘积 |
| mean() |
所有值的平均值 |
| median() |
所有值的中位数 |
| mode() |
值的模值 |
| std() |
值的标准偏差 |
| min() |
所有值中的最小值 |
| max() |
所有值中的最大值 |
| abs() |
绝对值 |
| cumsum() |
累计总和 |
| cumprod() |
累计乘积 |
| describe() |
平均值，标准差和IQR值 |
自定义函数应用
| 属性或方法 |
说明 |
| pipe() |
表格函数应用 |
| apply() |
行或列函数应用 |
| applymap() |
元素函数应用 |
df = pd.DataFrame(np.arange(12).reshape(4,3),columns=['col1','col2','col3'])
print(df)
'''
col1 col2 col3
0 0 1 2
1 3 4 5
2 6 7 8
3 9 10 11
'''
def adder(x, y):
return x+y
data = df.pipe(adder, 2)
print(data)
'''
col1 col2 col3
0 2 3 4
1 5 6 7
2 8 9 10
3 11 12 13
'''
data = df.apply(np.mean)
print(data)
'''
col1 4.5
col2 5.5
col3 6.5
dtype: float64'''
data = df.apply(np.mean, axis=1)
print(data)
'''
0 1.0
1 4.0
2 7.0
3 10.0
dtype: float64'''
func = lambda x:x**2
data = df.applymap(func)
print(data)
'''
col1 col2 col3
0 0 1 4
1 9 16 25
2 36 49 64
3 81 100 121
'''
重建索引
| 属性或方法 |
说明 |
| reindex() |
重新排序现有数据以匹配一组新的标签,在没有标签数据的标签位置插入缺失值(NA)标记 |
| reindex_like() |
采取一个对象重新索引，其轴被标记为与另一个对象相同 |
| rename() |
基于一些映射(字典或者系列)或任意函数来重新标记一个轴 |
填充方式：method
| 参数 |
说明 |
| pad/ffill |
向前填充值 |
| bfill/backfill |
向后填充值 |
| nearest |
从最近的索引值填充 |
df = pd.DataFrame(np.arange(12).reshape(3,4))
print(df)
'''
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11'''
data = df.reindex(index=[0,2], columns=[1,2,4])
print(data)
'''
1 2 4
0 1.0 2.0 NaN
2 9.0 10.0 NaN
'''
df2 = pd.DataFrame(np.arange(24).reshape(6,4))
data = df.reindex_like(df2, method='ffill', limit=2)
print(data)
'''
0 1 2 3
0 0.0 1.0 2.0 3.0
1 4.0 5.0 6.0 7.0
2 8.0 9.0 10.0 11.0
3 8.0 9.0 10.0 11.0
4 8.0 9.0 10.0 11.0
5 NaN NaN NaN NaN
'''
data = df.rename(index={0:'first',1:'second',2:'third'},columns={0:'a',1:'b',2:'c',3:'d'})
print(data)
'''
a b c d
first 0 1 2 3
second 4 5 6 7
third 8 9 10 11
'''
迭代
迭代不同数据结构，i的意义不同，具体为：
- Series - 遍历值
- DataFrame - 遍历列标签
- Pannel - 遍历项目标签
特别的，DataFrame可使用一下函数遍历不同对象：
| 函数 |
说明 |
| iteritems() |
将每个列作为键，将值与值作为键和列值迭代为Series对象 |
| iterrows() |
返回迭代器，产生每个索引值以及包含每行数据的序列 |
| itertuples() |
将为DataFrame中的每一行返回一个产生一个命名元组的迭代器。元组的第一个元素将是行的相应索引值，而剩余的值是行值 |
df = pd.DataFrame({
'name':['Tom','Tom','Andy','tony','Andy','Tom','tony'],
'rank':[1,2,3,1,4,3,2],
'year':[2016,2014,2015,2013,2012,2009,2011]
})
for i in df:
print(i)
'''
name
rank
year
'''
for key,value in df.iteritems():
print(key)
print(value)
'''
name
0 Tom
1 Tom
2 Andy
3 tony
4 Andy
5 Tom
6 tony
Name: name, dtype: object
rank
0 1
1 2
2 3
3 1
4 4
5 3
6 2
Name: rank, dtype: int64
year
0 2016
1 2014
2 2015
3 2013
4 2012
5 2009
6 2011
Name: year, dtype: int64
'''
for key,value in df.iterrows():
print(key)
print(value)
'''
0
name Tom
rank 1
year 2016
Name: 0, dtype: object
1
name Tom
rank 2
year 2014
Name: 1, dtype: object
2
name Andy
rank 3
year 2015
Name: 2, dtype: object
3
name tony
rank 1
year 2013
Name: 3, dtype: object
4
name Andy
rank 4
year 2012
Name: 4, dtype: object
5
name Tom
rank 3
year 2009
Name: 5, dtype: object
6
name tony
rank 2
year 2011
Name: 6, dtype: object
'''
for item in df.itertuples():
print(item)
'''
Pandas(Index=0, name='Tom', rank=1, year=2016)
Pandas(Index=1, name='Tom', rank=2, year=2014)
Pandas(Index=2, name='Andy', rank=3, year=2015)
Pandas(Index=3, name='tony', rank=1, year=2013)
Pandas(Index=4, name='Andy', rank=4, year=2012)
Pandas(Index=5, name='Tom', rank=3, year=2009)
Pandas(Index=6, name='tony', rank=2, year=2011)'''
for item in df.itertuples():
print(item.name, item.rank, item.year)
'''
Pandas(Index=6, name='tony', rank=2, year=2011)
Tom 1 2016
Tom 2 2014
Andy 3 2015
tony 1 2013
Andy 4 2012
Tom 3 2009
tony 2 2011'''
操作字符串
| 函数 |
说明 |
| lower() |
将Series/Index中的字符串转换为小写 |
| upper() |
将Series/Index中的字符串转换为大写 |
| swapcase |
变换字母大小写 |
| strip() |
帮助从两侧的系列/索引中的每个字符串中删除空格(包括换行符) |
| split() |
用给定的模式拆分每个字符串 |
| cat(sep=”) |
使用给定的分隔符连接系列/索引元素 |
| replace(a,b) |
将值a替换为值b |
| len() |
计算字符串长度 |
| repeat(value) |
重复每个元素指定的次数 |
| count(pattern) |
返回模式中每个元素的出现总数 |
| islower() |
检查系列/索引中每个字符串中的所有字符是否小写，返回布尔值 |
| isupper() |
检查系列/索引中每个字符串中的所有字符是否大写，返回布尔值 |
| isnumeric() |
检查系列/索引中每个字符串中的所有字符是否为数字，返回布尔值 |
| contains(pattern) |
如果元素中包含子字符串，则返回每个元素的布尔值True，否则为False |
| startswith(pattern) |
如果系列/索引中的元素以模式开始，则返回true |
| endswith(pattern) |
如果系列/索引中的元素以模式结束，则返回true |
| find(pattern) |
返回模式第一次出现的位置 |
| findall(pattern) |
返回模式的所有出现的列表 |
日期
| 函数 |
说明 |
| date_range(”,periods,freq) |
通过指定周期periods和频率freq就可以创建日期序列,freq默认为天 |
| bdate_range() |
用来表示商业日期范围，它不包括星期六和星期天 |
dates = pd.date_range('2018.05.11','2018.5.15')
print(dates)
'''
DatetimeIndex(['2018-05-11', '2018-05-12', '2018-05-13', '2018-05-14',
'2018-05-15'],
dtype='datetime64[ns]', freq='D')
'''
dates = pd.date_range('2018/05/11',periods=5)
print(dates)
'''
DatetimeIndex(['2018-05-11', '2018-05-12', '2018-05-13', '2018-05-14',
'2018-05-15'],
dtype='datetime64[ns]', freq='D')
'''
dates = pd.date_range('20180511', periods=5, freq='M')
print(dates)
'''
DatetimeIndex(['2018-05-31', '2018-06-30', '2018-07-31', '2018-08-31',
'2018-09-30'],
dtype='datetime64[ns]', freq='M')
'''
freq参数
| 别名 |
说明 |
| A |
年度结束频率 |
| BA |
商务年底结束频率 |
| Q |
季度结束频率 |
| BQ |
商务季度结束频率 |
| QS |
季度开始频率 |
| BQS |
商务季度开始频率 |
| M |
月结束频率 |
| BM |
商务月结束频率 |
| MS |
月起始频率 |
| BMS |
商务月开始频率 |
| W |
每周频率 |
| B |
工作日频率 |
| D |
自然日频率 |
| H |
小时频率 |
| T, min |
分钟的频率 |
| S |
秒频率 |
| L, ms |
毫秒 |
