Python：pandas（三）——DataFrame

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

②iloc

与loc的区别在于，iloc只接受 整数值 （从0到length-1）和 boolean array

接受的输入值：

单个整数，如5；

整数的list或array，如[ 4 , 3 , 0 ]

整数切片，如1：7；也可以用冒号:，代表全部行/列

boolean array

callable函数，接受一个参数（Series或DataFrame），返回值为上文a到d中的类型

如果想用 loc 提取某一列的最后一号元素，那么 loc[i,j] 中的 i 不能写为 -1 ，可以这样写：

lastEle = df.loc[df.index[-1],column_name]

③访问某一列

df.列名 或 df['列名'] 的方式访问某一列

该方式只能访问一列，如果要访问多列请用上文①②讲的方法。

2.5.3、返回DataFrame的array形式： values

返回值类型为 numpy.ndarray

只返回DataFrame中的值，而不返回label行和列。

官方文档中推荐用 df.to_numpy() 代替。

三种将 DataFrame 转化为 ndarray 的方法：

#假设df是一个DataFrame
#df→ndarray
df_array=df.values
df_array=df.to_numpy()
df_array=np.array(df)

2.5.4、检查DataFrame是否为空： empty

df.empty ：如果df.empty中没有任何元素，就会返回True

用法为： df.xxx( ... )

假设有一个 DataFrame df ，我们想把它的 'Time' 列设置为 Index

df_new = df.set_index('Time',inplace=False)

需要注意的是，如果参数inplace=False，那么并不是对df本身进行修改，而是返回一个修改后的DataFrame ，所以需要用一个额外的变量承接（如上文 df_new ）

2）applymap

对DataFrame中的所有元素使用某个函数，相当于对 list 使用 map 的用法

把df中的所有0值设为Null

df.applymap(lambda x:Null if x==0 else x)

3）apply

对DataFrame中每行/列的所有元素使用某个函数

df.apply(
    func, axis=0, raw=False, result_type=None,
    args=(), **kwds
应用于每一行/每一列的函数值
0与'index'
1与'columns'
0：为每一列应用该函数
1：为每一行应用该函数
False
决定传入的行与列是Series还是ndarray对象：
False：Series
True：ndarray
result_type
{'expand','reduce','broadcast',None}
只用于axis=1时
'expand'结果会被加入到DataFrame的扩展列中
'reduce'单独返回结果列
'broadcast'结果保存为原DataFrame中，相当于用结果列替换原DataFrame中的列
tuple
传入func的参数
4）添加一列、一行
assign
如果只是执行df.assign，那么只会返回一个结果，不会在原df上起作用。
因此要想把结果覆盖原DF，就要写成：
df=df.assign(...)
df_new = df.assign( 列名1 = Series、Array、List ,
　　　　　　          列名2 = Series、Array、List)
参数中的列名n不需要加引号；Series、Array、List要和df长度一致。
假设已经有一个DataFrame df，有个长度与它相等的Series S，我们要把S添加到df中，命名为'New_Column'
df_new = df.assign( NewColumn=S )
如果是对已有列进行运算得到的新列，可以用lambda匿名函数和df[列名]的结合，例如：
df.assign(temp_f=lambda x: x['temp_c'] * 9 / 5 + 32,
          temp_k=lambda x: (x['temp_f'] +  459.67) * 5 / 9)
append
和assign一样，append的结果不会作用于原DataFrame。
因此要想把结果覆盖原DF，就要写成：
df=df.append(...)
df_new = df.append(other, ignore_index=False, verify_integrity=False, sort=False)
df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'), index=['x', 'y'])
x  1  2
y  3  4
df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'), index=['x', 'y'])
x  5  6
y  7  8
df.append(df2, ignore_index=True)
0  1  2
1  3  4
2  5  6
3  7  8
 如果报错TypeError: Can only append a Series if ignore_index=True or if the Series has a name，则需要加参数ignore_index=True
5）between_time
提取Index位于指定时间段内的行构成新的DataFrame。
注意，Index必须是DateTime类型（如何转化可以看Pandas：从CSV中读取一个含有datetime类型的DataFrame、单项时间数据获取）
df.between_time(
    start_time, end_time, include_start=True, 
    include_end=True, axis=None
2018-04-09 00:00:00  1
2018-04-10 00:20:00  2
2018-04-11 00:40:00  3
2018-04-12 01:00:00  4

#筛选在此区间内的行
ts.between_time('0:15', '0:45')
2018-04-10 00:20:00  2
2018-04-11 00:40:00  3

#筛选不在此区间内的行
ts.between_time('0:45', '0:15')
2018-04-09 00:00:00  1
2018-04-12 01:00:00  4
 6）interpolate
用插值的方法填充NaN值。
请注意，对于多重索引（MultiIndex）的DataFrame/Series，只支持用method='linear'的形式。
    df.interpolate(
        method='linear', axis=0, limit=None, inplace=False,
        limit_direction=None, limit_area=None, downcast=None, **kwargs
'index'、'values'：使用索引值作为待填充值；
'pad'：使用存在的值填充空值；
'nearest'、'zero'、'slinear'、'quadratic'、'cubic'、'spline'、
　　　'barycentric'、'polynomial'：最近邻、零值、...；
'krogh'、‘piecewise_polynomial’, ‘spline’, ‘pchip’,
　　　‘akima’, ‘cubicspline’：用SciPy中相应的插值方法；
'from_derivatives'：scipy.interpolate.BPoly.from_derivatives
'linear'
{0或'index'、1或'columns'、None}
沿着哪个方向插值
limit
最多填充的连续空值数
inplace
False
是否替换原值
limit_direction
{'forward'、'backward'、'both'}
对于连续的空值，依照该参数说明的方向进行填充。
如果指定参数'limit'：如果插值方法是'pad'或'ffill'，那么'limit_direction'必须是'forward'；如果插值方法是'backfill'或'bfill'，那么'limit_direction'必须是'backwards'；
如果未指定参数'limit'：如果插值方法是'backfill'或'bfill'，那么'limit_direction'默认是'backward'；其他情况都是'forward'
Series、DataFrame、None
如果inplace=True，那么返回None，原来的DataFrame中的空值被新值填充；如果inplace=False，那么返回一个填充后的Series、DataFrame
1、什么参数都不写，用默认方式插值（即线性插值法——linear）
s = pd.Series([0, 1, np.nan, 3])
0    0.0
1    1.0
2    NaN
3    3.0
dtype: float64
s.interpolate()
0    0.0
1    1.0
2    2.0
3    3.0
dtype: float64
2、padding插值，一次最多填充两个连续的空值
s = pd.Series([np.nan, "single_one", np.nan,
               "fill_two_more", np.nan, np.nan, np.nan,
               4.71, np.nan])

0              NaN
1       single_one
2              NaN
3    fill_two_more
4              NaN
5              NaN
6              NaN
7             4.71
8              NaN
dtype: object

s.interpolate(method='pad', limit=2)
0              NaN
1       single_one
2       single_one
3    fill_two_more
4    fill_two_more
5    fill_two_more
6              NaN
7             4.71
8             4.71
dtype: object
3、用'forward'方式插值——空值用它前边的值替换：
df = pd.DataFrame([(0.0, np.nan, -1.0, 1.0),
                   (np.nan, 2.0, np.nan, np.nan),
                   (2.0, 3.0, np.nan, 9.0),
                   (np.nan, 4.0, -4.0, 16.0)],
                  columns=list('abcd'))
     a    b    c     d
0  0.0  NaN -1.0   1.0
1  NaN  2.0  NaN   NaN
2  2.0  3.0  NaN   9.0
3  NaN  4.0 -4.0  16.0
df.interpolate(method='linear', limit_direction='forward', axis=0)
     a    b    c     d
0  0.0  NaN -1.0   1.0
1  1.0  2.0 -2.0   5.0
2  2.0  3.0 -3.0   9.0
3  2.0  4.0 -4.0  16.0
4、多项式插值——order指明多项式的次数
df['d'].interpolate(method='polynomial', order=2)
0     1.0
1     4.0
2     9.0
3    16.0
Name: d, dtype: float64
 7）drop
从DataFrame中删除指定的行、列。
df.drop(
    labels=None, axis=0, index=None, columns=None,
    level=None, inplace=False, errors='raise'
df = pd.DataFrame(np.arange(12).reshape(3, 4),
                  columns=['A', 'B', 'C', 'D'])
   A  B   C   D
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
删除列/columns；
df.drop(['B', 'C'], axis=1)
   A   D
0  0   3
1  4   7
2  8  11
df.drop(columns=['B', 'C'])
   A   D
0  0   3
1  4   7
2  8  11
删除行/index
df.drop(index=[0, 1])
   A  B   C   D
2  8  9  10  11
注意，这里的index=[0,1]指的是删除索引为0，1的行，并非删除第0、1行。
换言之，如果索引变成了"first,second"，那么这里的写法就是index=["first","second"]
删除/清空/clear所有行
df.drop(index=df.index,inplace=True)
删除根据条件删除其中的若干行
可以先通过循环，把这些行的行号保存为list，再用df.drop(index=list)
del_list=[]
for i in range(data.shape[0]):
    if data.iloc(i,0)<3:
        del_list.append(data.index[i])
data.drop(index=del_list,inplace=True)
 8）head、tail
head(n)：前n行
tail(n)：后n行
不写n默认为5
9）count与sum
count：统计每列或每行非空值的个数
sum：统计每列或者每行非空值的和
使用count+sum的组合可以实现统计整个DF中非空值的个数：
num=df.count().sum()
count、sum默认是统计每列非空值，如果要统计每行，需要写成count(1)、sum(1)
10）sort_values
按照某列的值排序
DataFrame.sort_values(by, *, axis=0, ascending=True, inplace=False,
 kind='quicksort', na_position='last', ignore_index=False, key=None)
按照C列进行降序排序
df.sort_values('C',ascending=False,inplace=True)
如果没有inplace=True，那么排序不会作用于原DataFrame
11）rename
重命名标签行、标签列
df.rename(columns={'old_name1':'new_name1','old_name2:new_name2'})#分别重命名各列
df.rename(index={'old_name1':'new_name1','old_name2:new_name2'})#分别重命名各行

如果不加参数inplace，则不会作用于原DF
columns、index后必须跟dict类型或者某个可以作用于全部行/列的函数（例如str.lower就是把所有标签小写化）
df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
df.rename(columns={"A": "a", "B": "c"}) #将A列改名a，B列改名c

0  1  4
1  2  5
2  3  6
df.rename(columns=str.lower)
0  1  4
1  2  5
2  3  6