Series第四讲 重新索引、选择、标签 操作 (下)

由于第四讲涉及方法较多，此处分为上下两节各讲一部分。防止🧠混乱

重新索引、选择、标签方法总览(下)

• Series.reindex()
• Series.reindex_like()
• Series.rename()
• Series.rename_axis()
• Series.reset_index()
• Series.sample()
• Series.set_axis()
• Series.take()
• Series.truncate()
• Series.where()
• Series.mask()
• Series.add_prefix()
• Series.add_suffix()
• Series.filter()

详细介绍

先来创建一个Series, 一个DataFrame

In [2]: s = pd.Series([1, 2, 3, 4, None], index=['a', 'b', 'c', 'd', 'e'])      

In [3]: s                                                                       
Out[3]: 
a    1.0
b    2.0
c    3.0
d    4.0
e    NaN
dtype: float64

In [20]: df = pd.DataFrame({"num_legs": [4, 4, 2], 
    ...:                    "num_arms": [0, 0, 2]}, 
    ...:                   ["dog", "cat", "monkey"])                            

In [21]: df                                                                     
Out[21]: 
        num_legs  num_arms
dog            4         0
cat            4         0
monkey         2         2

1. Series.reindex()

Series.reindex(index=None, **kwargs)

根据指定 参数(index) 更新索引

常用参数介绍：

• fill_value：scalar, default np.NaN 处理缺失值

In [3]: s.reindex(['a', 'b', 'f'])                                              
Out[3]: 
a    1.0
b    2.0
f    NaN
dtype: float64

# 指定缺失值 fill_value
In [4]: s.reindex(['a', 'b', 'f'], fill_value=0.98)                             
Out[4]: 
a    1.00
b    2.00
f    0.98
dtype: float64

reindex 的其他关键字参数(如果看过前几篇文章应该对下面几个参数比较熟悉了)：

• method：{None, ‘backfill’/’bfill’, ‘pad’/’ffill’, ‘nearest’}
• copy：bool, default True
• level：int or name
• limit：int, default None

2. Series.reindex_like()

Series.reindex_like(other, method=None, copy=True, limit=None, tolerance=None)

根据参数 other 里的索引(行或列)替换 Series 的索引

常用参数介绍：

• other：Object of the same data type 可以是Series或DataFrame

In [6]: s.reindex_like(pd.Series([7, 8, 9], index=['a', 'b', 'c']))             
Out[6]: 
a    1.0
b    2.0
c    3.0
dtype: float64

# 原Series中不存在的索引的value置为nan
In [6]: s.reindex_like(pd.Series([7, 8, 9], index=['a', 'b', 'c']))             
Out[6]: 
a    1.0
b    2.0
c    3.0
dtype: float64

# other也可以是df类型
In [9]: s.reindex_like(pd.DataFrame([7, 8, 9],index=['a', 'b', 'c']))           
Out[9]: 
a    1.0
b    2.0
c    3.0
dtype: float64

3. Series.rename()

Series.rename(index=None, *, axis=None, copy=True, inplace=False, level=None, errors='ignore')

重置Series的 index labels 或者 Series.name

常用参数介绍：

• index：scalar, hashable sequence, dict-like or function, optional 前两者(scalar, hashable sequence)改变labels，后两者(dict-like or function)改变Series.name

# 改变Series.name
In [12]: s.rename('s_name')                                                     
Out[12]: 
a    1.0
b    2.0
c    3.0
d    4.0
e    NaN
Name: s_name, dtype: float64

# function更改labels
In [15]: s.rename(lambda x: 'pre_' + x)                                         
Out[15]: 
pre_a    1.0
pre_b    2.0
pre_c    3.0
pre_d    4.0
pre_e    NaN
dtype: float64

# dict更改labels 不存在的索引不会被创建(比如z)
In [17]: s.rename({'a': 'pre_a', 'b': 'pre_b', 'z': 'pre_z'})                   
Out[17]: 
pre_a    1.0
pre_b    2.0
c        3.0
d        4.0
e        NaN
dtype: float64

4. Series.rename_axis()

Series.rename_axis(**kwargs)

设置轴(行或列)的name。

注意⚠️：

• rename() 改变的是对象的 name (Series.name)；
• rename_axis() 改变的是轴的 name (Series.index.name)

常用参数介绍：

• mapper：scalar, list-like, optional 标量或者列表，表示轴的名称
• index, columns：scalar, list-like, dict-like or function, optional 推荐使用
• axis：{0 or ‘index’, 1 or ‘columns’}, default 0
• copy：bool, default True 是否复制基础数据
• inplace：bool, default False 是否原地修改

# 等价于 s.rename_axis(index='s_name')
In [22]: s.rename_axis('s_name')                                                
Out[22]: 
s_name
a    1.0
b    2.0
c    3.0
d    4.0
e    NaN
dtype: float64

In [46]: s.rename_axis('s_name').index                                          
Out[46]: Index(['a', 'b', 'c', 'd', 'e'], dtype='object', name='s_name')

# 修改列轴的name
In [43]: df.rename_axis(columns='my_col')                                       
Out[43]: 
my_col  num_legs  num_arms
dog            4         0
cat            4         0
monkey         2         2

In [45]: df.rename_axis(columns='my_col').columns                               
Out[45]: Index(['num_legs', 'num_arms'], dtype='object', name='my_col')

5. Series.reset_index()

Series.reset_index(level=None, drop=False, name=None, inplace=False)

生成一个新的带有重置索引的DataFrame或Series。

当索引需要被视为列时，或者索引无意义并且需要在其他操作之前重置为默认值时，此功能很有用。

常用参数介绍：

• level：int, str, tuple, or list, default optional 多级索引时的参数
• drop：bool, default False 如果为True，则只重置索引，并不会转换成列
• name：object, optional (⚠️ df.reset_index没有这个参数)

In [48]: df.reset_index()                                                       
Out[48]: 
    index  num_legs  num_arms
0     dog         4         0
1     cat         4         0
2  monkey         2         2

# 转换成列后对新的列命名
In [56]: s.reset_index(name='new_name')                                         
Out[56]: 
  index  new_name
0     a       1.0
1     b       2.0
2     c       3.0
3     d       4.0
4     e       NaN

# 只重置索引，不转换成列
In [49]: df.reset_index(drop=True)                                              
Out[49]: 
   num_legs  num_arms
0         4         0
1         4         0
2         2         2

6. Series.sample()

Series.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)

进行随机抽样

常用参数介绍：

• n 和 frac 不能一起使用，当 frac>1 时，replace 必须为 True
• replacebool, default False 允许或不允许对同一行进行多次采样

# 随机选三个
In [58]: s.sample(n=3)                                                          
Out[58]: 
b    2.0
e    NaN
d    4.0
dtype: float64

# 选一半 基数的话选 n/2-1个
In [59]: s.sample(frac=0.5)                                                     
Out[59]: 
d    4.0
b    2.0
dtype: float64

# 数量翻倍 随机选 原Series并不会改变
In [61]: s.sample(frac=2, replace=True)                                         
Out[61]: 
d    4.0
e    NaN
b    2.0
b    2.0
b    2.0
c    3.0
a    1.0
e    NaN
a    1.0
c    3.0
dtype: float64

7. Series.set_axis()

Series.set_axis(labels, axis=0, inplace=False)

行标签的索引可以通过分配类似列表或索引的方式来更改

常用参数介绍：

• labels：list-like, Index 新索引的值，长度必须和原Series的索引长度一致

In [65]: s.set_axis(['x', 'y', 'z', 'a', 'b'])                                  
Out[65]: 
x    1.0
y    2.0
z    3.0
a    4.0
b    NaN
dtype: float64

8. Series.take()

Series.take(indices, axis=0, is_copy=None, **kwargs)

沿轴返回给定位置索引中的元素。 这意味着我们没有根据对象的index属性中的实际值进行索引。我们正在根据元素在对象中的实际位置建立索引.

常用参数介绍：

• labels：indices：array-like 一个整数数组，表示元素位置
• axis：{0 or ‘index’, 1 or ‘columns’, None}, default 0

# 选择第0行
In [67]: df.take([0])                                                           
Out[67]: 
     num_legs  num_arms
dog         4         0

# 选择第0行和第2行
In [70]: df.take([0, 2])                                                        
Out[70]: 
        num_legs  num_arms
dog            4         0
monkey         2         2

# 选择第0列
In [72]: df.take([0], axis=1)                                                   
Out[72]: 
        num_legs
dog            4
cat            4
monkey         2

目前来看 take 这个功能可以用 iloc 来代替实现

9. Series.truncate()

Series.truncate(before=None, after=None, axis=None, copy=True)

在某个索引值之前和之后截断Series或DataFrame，保留数据before到after(包含before和after且before必须在after的前面)

In [75]: s.truncate('b', 'c')                                                   
Out[75]: 
b    2.0
c    3.0
dtype: float64

10. Series.where()

Series.where(cond, other=nan, inplace=False, axis=None, level=None, errors='raise', try_cast=False)

替换条件为False的值。如果cond为True，原数据不变；如果cond为False，原数据用other值替换。

常用参数介绍：

• cond：bool Series/DataFrame, array-like, or callable 判断条件
• other：scalar, Series/DataFrame, or callable 要替换的值
• try_cast：bool, default False 尝试将结果类型转换为输入的类型

# 大于2的不变，其他的全变成0
In [82]: s.where(s>2, 0)                                                        
Out[82]: 
a    0.0
b    0.0
c    3.0
d    4.0
e    0.0
dtype: float64

11. Series.mask()

Series.mask(cond, other=nan, inplace=False, axis=None, level=None, errors='raise', try_cast=False)

与 where() 相反，满足条件的用other值替换，不满足的数据保持不变

In [84]: s.mask(s>2, 0)                                                         
Out[84]: 
a    1.0
b    2.0
c    0.0
d    0.0
e    NaN
dtype: float64

12. Series.add_prefix()

Series.add_prefix(prefix)

对于Series，行标签带有前缀。对于DataFrame，列标签带有前缀

In [86]: s.add_prefix('pre_')                                                   
Out[86]: 
pre_a    1.0
pre_b    2.0
pre_c    3.0
pre_d    4.0
pre_e    NaN
dtype: float64

In [88]: df.add_prefix('pre_')                                                  
Out[88]: 
        pre_num_legs  pre_num_arms
dog                4             0
cat                4             0
monkey             2             2

13. Series.add_suffix()

Series.add_suffix(suffix)

同 add_prefix() 类似，不过这个是添加后缀

14. Series.filter()

Series.filter(items=None, like=None, regex=None, axis=None)

根据指定的索引标签对DataFrame的行或列进行子集设置，不会在其内容上过滤DataFrame，过滤器将应用于索引标签。

常用参数介绍：

• items：list-like 意思是labels列表，可以指定index或columns
• like：str 感觉像模糊匹配labels包含like的轴
• regex：str (regular expression)
• axis：{0 or ‘index’, 1 or ‘columns’, None}, default None 作用的轴
• items, like, and regex 三个参数相互排斥 只能选一个

# items
In [91]: df.filter(items=['dog', 'monkey'], axis=0)                             
Out[91]: 
        num_legs  num_arms
dog            4         0
monkey         2         2

# like
In [93]: df.filter(like='og', axis=0)                                           
Out[93]: 
     num_legs  num_arms
dog         4         0

# regex 以d开始且g结尾的匹配
In [101]: df.filter(regex='^d.*g$', axis=0)                                     
Out[101]: 
     num_legs  num_arms
dog         4         0

明天继续 坚持 ✊ ✊ ✊！！！