• 【Python从入门到进阶】58、Pandas库中Series对象的操作(一)

    接上篇《57、Pandas入门指南：背景、应用场景与基本操作》
    上一篇我们讲解了Pandas的背景以及应用场景与基本操作，本篇我们来讲解Pandas库中Series对象的基本概念和相关操作。

    一、引言

    Pandas库中的Series对象是其核心数据结构之一，它在数据分析中扮演着重要的角色。Series可以视为一种带有标签的一维数组，能够高效地处理各种类型的数据。

    首先，Series类似于一维数组，但与之不同的是，Series的每个元素都拥有一个标签，这些标签被称为“索引”（index）。这种标签化的特性使得Series在数据分析和处理中非常灵活和方便。

    其次，Series可以存储多种类型的数据，包括但不限于整数（int）、浮点数（float）、字符串（str）、布尔值（bool）、Python对象等。这种数据类型的多样性使得Series能够处理各种复杂的数据集，并满足各种数据分析和处理的需求。

    在Pandas中，Series对象具有许多实用的属性和方法，如索引（index）、数据（values）、数据类型（dtype）、形状（shape）等属性，以及切片、筛选、排序、运算等操作。这些属性和方法使得我们可以方便地对数据进行各种处理和分析。

    此外，Series对象还可以与Pandas中的另一个核心数据结构——DataFrame进行交互。DataFrame是一个二维的、大小可变的、且可以包含异构类型列的表格型数据结构，而Series则可以被视为DataFrame的一列。因此，我们可以通过将Series对象嵌入到DataFrame中，来实现更复杂的数据处理和分析任务。

    总之，Pandas库中的Series对象是一种强大而灵活的数据结构，它不仅能够存储多种类型的数据，而且具有许多实用的属性和方法，可以帮助我们高效地进行数据分析和处理。在接下来的内容中，我们将详细介绍Series对象的创建、基本属性、数据操作、运算等方面的内容，并通过案例实践来展示其应用。

    二、Series对象的创建

    在Pandas库中，Series对象可以通过多种方式创建。这些方式主要基于Python中常见的数据结构，如列表、字典、NumPy数组等。以下是几种常见的创建Series对象的方法：

    1、使用列表创建Series

    当我们有一个包含数据的列表，并且想要将其转换为一个带有索引的Series对象时，可以直接使用Pandas的Series()函数。默认情况下，列表中的元素会成为Series的数据，而索引则会自动从0开始递增。

    1. import pandas as pd  
    2.   
    3. data = [1, 2, 3, 4, 5]  
    4. s = pd.Series(data)  
    5. print(s)  
    6. # 输出:  
    7. # 0    1  
    8. # 1    2  
    9. # 2    3  
    10. # 3    4  
    11. # 4    5  
    12. # dtype: int64

    如果希望自定义索引，可以传递一个额外的参数index给Series()函数。

    1. index = ['a', 'b', 'c', 'd', 'e']  
    2. s = pd.Series(data, index=index)  
    3. print(s)  
    4. # 输出:  
    5. # a    1  
    6. # b    2  
    7. # c    3  
    8. # d    4  
    9. # e    5  
    10. # dtype: int64

    2、使用字典创建Series

    字典是Python中用于存储键值对的数据结构。在创建Series时，字典的键会被用作索引，而值则成为数据。

    1. dict_data = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}  
    2. s = pd.Series(dict_data)  
    3. print(s)  
    4. # 输出:  
    5. # a    1  
    6. # b    2  
    7. # c    3  
    8. # d    4  
    9. # e    5  
    10. # dtype: int64

    如果字典的键不是唯一的，Pandas会保留最后一个出现的值。

    3、使用NumPy数组创建Series

    NumPy是Python中用于科学计算的库，它提供了高效的数组和矩阵运算。当我们有一个NumPy数组时，可以直接将其传递给Series()函数来创建一个Series对象。

    1. import numpy as np  
    2.   
    3. np_data = np.array([1, 2, 3, 4, 5])  
    4. s = pd.Series(np_data)  
    5. print(s)  
    6. # 输出:  
    7. # 0    1  
    8. # 1    2  
    9. # 2    3  
    10. # 3    4  
    11. # 4    5  
    12. # dtype: int64

    同样，我们也可以指定索引。

    1. index = ['a', 'b', 'c', 'd', 'e']  
    2. s = pd.Series(np_data, index=index)  
    3. print(s)  
    4. # 输出:  
    5. # a    1  
    6. # b    2  
    7. # c    3  
    8. # d    4  
    9. # e    5  
    10. # dtype: int64

    4、使用标量值创建Series

    如果我们想创建一个所有元素都相同的Series，可以传递一个标量值（如整数、浮点数、字符串等）给Series()函数，并指定索引的长度。

    1. index = ['a', 'b', 'c', 'd', 'e']  
    2. s = pd.Series(1, index=index)  
    3. print(s)  
    4. # 输出:  
    5. # a    1  
    6. # b    1  
    7. # c    1  
    8. # d    1  
    9. # e    1  
    10. # dtype: int64

    5、从其他数据结构创建Series

    Pandas还支持从其他数据结构（如CSV文件、Excel文件、SQL数据库等）中读取数据并创建Series对象。这通常涉及到使用Pandas的read_csv()、read_excel()等函数，但这些内容超出了本节的讨论范围。

    总之，Pandas提供了多种灵活的方式来创建Series对象，使得我们能够方便地将各种类型的数据转换为Pandas的数据结构进行后续处理和分析。

    三、Series对象的基本属性

    Series对象在Pandas库中提供了多种基本属性，这些属性帮助我们快速获取关于数据序列的重要信息。以下是Series对象的一些基本属性及其描述：

    1、index

    index属性用于获取Series对象的索引标签。这些标签默认是整数，从0开始递增，但也可以在创建Series时自定义。

    1. import pandas as pd  
    2.  
    3. s = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])  
    4. print(s.index)  
    5. # 输出: Index(['a', 'b', 'c', 'd', 'e'], dtype='object')

    2、values

    values属性返回一个NumPy数组，其中包含Series中的数据。这个属性提供了对数据的直接访问，允许我们使用NumPy的函数和方法来操作数据。

    1. s = pd.Series([1, 2, 3, 4, 5])  
    2. print(s.values)  
    3. # 输出: array([1, 2, 3, 4, 5])

    3、dtype

    dtype属性用于获取Series中数据的数据类型。Pandas会根据数据的内容自动推断数据类型，如整数、浮点数、字符串等。

    1. s = pd.Series(['a', 'b', 'c', 'd', 'e'])  
    2. print(s.dtype)  
    3. # 输出: dtype('O')  # 注意：'O'表示对象类型，通常用于存储字符串  
    4.  
    5. s = pd.Series([1, 2, 3, 4, 5])  
    6. print(s.dtype)  
    7. # 输出: dtype('int64')

    4、shape

    shape属性返回一个元组，表示Series的维度。对于Series来说，它总是返回一个包含一个元素的元组，表示数据的长度。

    1. s = pd.Series([1, 2, 3, 4, 5])  
    2. print(s.shape)  
    3. # 输出: (5,)

    5、size

    size属性返回Series中元素的数量，即数据的长度。这个属性是一个整数，等价于len(series)。

    1. s = pd.Series([1, 2, 3, 4, 5])  
    2. print(s.size)  
    3. # 输出: 5

    6、name

    name属性用于获取或设置Series的名称。这个属性通常用于在DataFrame中标识不同的列。

    1. s = pd.Series([1, 2, 3, 4, 5], name='example')  
    2. print(s.name)  
    3. # 输出: example  
    4.  
    5. s.name = 'new_name'  
    6. print(s.name)  
    7. # 输出: new_name

    7、axes

    axes属性返回一个包含Series索引的列表。对于Series来说，它只包含一个索引轴。

    1. s = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])  
    2. print(s.axes)  
    3. # 输出: [Index(['a', 'b', 'c', 'd', 'e'], dtype='object')]

    8、nbytes

    nbytes属性返回Series对象在内存中占用的字节数。这个属性对于了解数据集的内存使用情况很有用。

    1. s = pd.Series([1, 2, 3, 4, 5])  
    2. print(s.nbytes)  
    3. # 输出会根据Series的数据类型和大小有所不同

    9、头部和尾部数据查看

    Series的头部和尾部数据查看，使用head()、tail()函数：

    1. import pandas as pd
    2.  
    3. data = [1,2,3,4,5]
    4. s = pd.Series(data)
    5. print("[头部第一个数据]\n", s.head(1))
    6. print("[尾部后两个数据]\n", s.tail(2))
    7. # 输出:
    8. # [头部第一个数据]
    9. #  0    1
    10. # dtype: int64
    11. # [尾部后两个数据]
    12. #  3    4
    13. #  4    5

    这些基本属性为我们提供了关于Series对象的重要信息，使我们能够更好地理解和操作数据。

    四、Series对象的数据操作

    Pandas的Series对象提供了丰富的数据操作方法，这些方法使得我们可以轻松地对数据进行各种处理和分析。以下是Series对象的一些常用数据操作方法：

    1、索引和切片

    Series对象支持基于标签的索引和基于位置的切片操作。我们可以使用索引标签来访问单个元素或子集，也可以使用切片语法来访问连续的元素范围。

    1. import pandas as pd  
    2.   
    3. s = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])  
    4.   
    5. # 基于标签的索引  
    6. print(s['a'])  # 输出: 1  
    7.   
    8. # 基于位置的切片  
    9. print(s[1:4])  # 输出: b    2  
    10.                 #      c    3  
    11.                 #      d    4  
    12.                 # dtype: int64

    2、修改数据

    Series对象是可变的，我们可以直接修改其元素的值。

    1. s['a'] = 10  
    2. print(s)  # 输出: a    10  
    3.           #      b     2  
    4.           #      c     3  
    5.           #      d     4  
    6.           #      e     5  
    7.           # dtype: int64

    3、算术运算

    Series对象支持常见的算术运算，如加法、减法、乘法、除法等。这些运算可以在Series之间、Series与标量之间进行。

    1. s1 = pd.Series([1, 2, 3, 4, 5])  
    2. s2 = pd.Series([10, 20, 30, 40, 50])  
    3.   
    4. # Series之间的加法  
    5. print(s1 + s2)  # 输出: 0    11  
    6.                 #      1    22  
    7.                 #      2    33  
    8.                 #      3    44  
    9.                 #      4    55  
    10.                 # dtype: int64  
    11.   
    12. # Series与标量的加法  
    13. print(s1 + 1)  # 输出: 0    2  
    14.                 #      1    3  
    15.                 #      2    4  
    16.                 #      3    5  
    17.                 #      4    6  
    18.                 # dtype: int64

    4、比较运算

    Series对象还支持比较运算，如等于、不等于、大于、小于等。这些运算的结果是一个布尔型的Series对象。

    1. print(s1 > 2)  # 输出: 0    False  
    2.                 #      1    False  
    3.                 #      2     True  
    4.                 #      3     True  
    5.                 #      4     True  
    6.                 # dtype: bool

    5、排序

    使用sort_values()方法可以对Series对象进行排序。默认情况下，数据按升序排序，但也可以指定ascending=False进行降序排序。

    1. s = pd.Series([5, 1, 4, 2, 3])  
    2. print(s.sort_values())  # 输出: 0    1  
    3.                         #      3    2  
    4.                         #      4    3  
    5.                         #      2    4  
    6.                         #      1    5  
    7.                         # dtype: int64

    6、唯一值和计数

    使用unique()方法可以获取Series对象中的唯一值，而value_counts()方法则可以计算每个唯一值出现的次数。

    1. s = pd.Series(['cat', 'dog', 'cat', 'elephant', 'elephant', 'dog'])  
    2. print(s.unique())  # 输出: array(['cat', 'dog', 'elephant'], dtype=object)  
    3. print(s.value_counts())  # 输出: elephant      2  
    4.                          # cat           2  
    5.                          # dog           2  
    6.                          # dtype: int64

    7、数据映射

    使用map()方法可以将Series中的每个元素映射到另一个值。这通常与字典一起使用，字典的键是原始值，值是映射后的值。

    1. s = pd.Series(['cat', 'dog', 'elephant'])  
    2. mapping = {'cat': 'kitten', 'dog': 'puppy', 'elephant': 'baby elephant'}  
    3. print(s.map(mapping))  # 输出: 0         kitten  
    4.                        # 1          puppy  
    5.                        # 2    baby elephant  
    6.                        # dtype: object

    8、字符串方法

    如果Series对象包含字符串类型的数据，那么可以调用字符串方法来处理这些数据。Pandas会自动将方法应用于每个元素。以下是一个例子，使用str.replace()方法将Series对象中每一个'a'替换为'b'：

    1. import pandas as pd  
    2.   
    3. # 创建一个包含字符串的Series对象  
    4. s = pd.Series(['apple', 'banana', 'cat', 'data', 'elephant'])  
    5.   
    6. # 使用str.replace()方法将'a'替换为'b'  
    7. s_replaced = s.str.replace('a', 'b')  
    8.   
    9. print(s_replaced)  
    10. # 输出:  
    11. # 0       bpple  
    12. # 1     bbnbnb  
    13. # 2         cbt  
    14. # 3       dbtb  
    15. # 4    elephant  
    16. # dtype: object

    关于Series对象操作的第一部分介绍完毕。下一篇我们继续学习Series对象的运算、函数用于、时间序列操作，以及Series的案例实践。

    转载请注明出处：https://guangzai.blog.csdn.net/article/details/139723986

  • 相关阅读:
    工程师如何对待开源 --- 一个老工程师的肺腑之言
    CSS 滚动驱动动画 animation-range
    Redisson源码解读-公平锁
    Oracle 19C 静默安装 GoldenGate
    开发前期准备工作
    【缓存】Spring全家桶中@CacheEvict无效情况共有以下几种
    ArrayList集合中元素的排序
    Jmeter —— 常用的几种断言方法（基本用法）
    从Matrix-ResourceCanary看内存泄漏监控
    Redis为什么这么快？Redis的线程模型与Redis多线程
  • 原文地址：https://blog.csdn.net/u013517797/article/details/139723986