Pandas 数据结构介绍——Series的转换和索引迭代

一、Series 定义的变换方法

构造一个Series对象。

>>> s = pd.Series(data=np.arange(7), dtype=np.float32, index=list('abcdefg'))
>>> s
a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
f    5.0
g    6.0
dtype: float32

1. pd.Series.astype(dtype, copy, errors)

创造新的数据类型的对象
参数: 
    dtype: data type, or dict of column name
        使用 numpy.dtype or Python type去构造对用类型的pandas对象；
        使用 {col: dtype, ...}，构造列的数据类型；
    copy: bool, default True
        当 copy=True 时，返回拷贝；
    errors: {'raise', 'ignore'}, default 'raise'
        控制对提供的无效数据引发的异常，
        - raise: 允许引发异常
        - ignore: 抑制异常，错误时返回原始对象

>>> s1 = s.astype(np.float64, copy=False)
>>> s1
 a    0.0
 b    1.0
 c    2.0
 d    3.0
 e    4.0
 f    5.0
 g    6.0
 dtype: float64

2. pd.Series.convert_dtypes(infer_objects: 'bool_t' = True, convert_string: 'bool_t' = True, convert_integer: 'bool_t' = True, convert_boolean: 'bool_t' = True, convert_floating: 'bool_t' = True)

尝试为对象推断更好的数据类型。
参数：
    infer_objects : bool, default True
        是否将数据类型转换为最佳类型；
    convert_string : bool, default True
        是否将对象数据类型转换为string类型；
    convert_integer : bool, default True
        如果可能，是否可以转换为整数扩展类型；
    convert_boolean : bool, defaults True
        是否可以转换为布尔类型；
    convert_floating : bool, defaults True
        如果可能，是否可以转换为浮动扩展类型。
        如果`convert_integer`也是True，优先转换为整数类型。

>>> s.convert_dtypes()
a    0
b    1
c    2
d    3
e    4
f    5
g    6
dtype: Int64

3. pd.Series.infer_objects()

尝试为对象列推断更好的数据类型。
尝试对对象数据类型的列进行软转换，使非对象列和不可转换列保持不变。推理规则与正常序列/数据帧构造期间的推理规则相同。

>>> s.infer_objects()
a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
f    5.0
g    6.0
dtype: float32

4. pd.Series.copy(deep: 'bool_t' = True)

返回对象的索引和数据的拷贝。
参数：
    deep: bool, default True
        True: 默认。将创造原始数据的拷贝，对拷贝的修改不会影响原始数据；
        False: 将创建一个新对象，而不复制调用对象的数据或索引（只复制对数据和索引的引用）。原始数据的任何更改都将反映在浅拷贝中（反之亦然）。

>>> s.copy()
a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
f    5.0
g    6.0
dtype: float32

5. pd.Series.bool()

该方法只能应用于只有一个bool类型元素的对象。

>>> pd.Series([True]).bool()
True

6. pd.Series.to_numpy(dtype=None, copy=False, na_value)

使用numpy的数组表示Series。
参数:
    dtype: str or numpy.dtype, optional
        array的数据类型
    copy: bool, default False
        是否拷贝，不是另一个数组的视图。
    na_value: Any,optional
        为缺失值使用的值。

>>> pd.Series([True]).to_numpy()
array([0., 1., 2., 3., 4., 5., 6.], dtype=float32)

7. pd.Series.to_list()

返回一个列表。

>>> s.to_list()
[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0]

二、Series 的索引和迭代

1. Series的索引

• Series.get(key)
  使用键来返回对象中对应的元素值。
• Series.at
  使用单个值的行/列标签对，来返回对应位置元素。
• Series.loc
  类似于 Series.at，可以是标签的列表、布尔列表，切片等。
• Series.iat
  使用单个整数值来返回对应位置的元素。
• Series.iloc
  类似于 Series.iat，可以是整数列表、布尔列表，切片等。

>>> s['b']
1.0
>>> s[1]
1.0

>>> s[['a','c']]
a    0.0
c    2.0
dtype: float32
>>> s[[2, 4]]
c    2.0
e    4.0
dtype: float32

2. Series的迭代

• Series.__iter__()
  返回一个值的迭代器。
• Series.items()
  返回 (key, value) 的迭代器。
• Series.keys()
  返回键的迭代器。
• Series.pop(item)
  返回一个元素，并从序列中删除。

# s.__iter__()
>>> for value in iter(s):
    	print(value)
0.0
1.0
2.0
3.0
4.0
5.0
6.0

# s.items()
>>> for key, value in s.items():
    	print(key, ':', value)
a : 0.0
b : 1.0
c : 2.0
d : 3.0
e : 4.0
f : 5.0
g : 6.0

# s.keys()
>>> for key in s.keys():
    	print(key)
a
b
c
d
e
f
g

# s.pop(key)
>>> s
a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
f    5.0
g    6.0
dtype: float32
>>> s.pop('c')
2.0
>>> s
a    0.0
b    1.0
d    3.0
e    4.0
f    5.0
g    6.0
dtype: float32