Pandas 学习笔记 (三) ：属性和常用方法汇总

基本功能

属性或方法	说明
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'''                                                                                  

# 判断 null
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
'''

# 计算sum，NA会被视为0   
print(df.loc['four'].sum())
'''0.0'''

# 丢去 NA 部分                                                          
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'''

# 填充 NA 部分                                                           
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'''

# 替换 replace()                                                      
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') # by：映射，函数，str或可迭代对象
print(grouped)
'''<pandas.core.groupby.DataFrameGroupBy object at 0x110ea99e8>'''

# 查看分组
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) # rank算术平均
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])  #rank的多种聚合
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']) # 默认为内inner
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'''

# 指定以 left 的数据合并
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
'''

# append 方向沿着纵向
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
'''

# 应用轴函数，行或列, axis默认为0，列                                                                
data = df.apply(np.mean)                                                               
print(data)     
'''
col1    4.5
col2    5.5
col3    6.5
dtype: float64'''
# 选择axis 行                                                 
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))
# NA部分向前填充，。填充数为2
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]
})

# DataFrame遍历列标签
for i in df:
    print(i)
'''
name
rank
year
'''

# 遍历 列标签 和 对应的series
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
'''

# 遍历 行标签 和 对应的series
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	毫秒