【100天精通python】Day6：python基础_基本数据结构，常用序列类型和运算符-阿里云开发者社区

在Python中，序列是一种基本的数据结构，用于存储一系列有序的元素。序列允许元素按照顺序排列，并且可以通过索引来访问每个元素。序列可以包含不同类型的元素，例如整数、浮点数、字符串等，甚至可以是其他序列，如列表、元组、字节串等。

1 常用的序列类型

python常用的序列类型包括：

列表（List）：有序、可变的序列，可以包含任意类型的元素。
元组（Tuple）：有序、不可变的序列，可以包含任意类型的元素。
字符串（String）：有序、不可变的字符序列。
集合（Set）：无序、可变的序列，元素不重复。
字典（Dictionary）：无序、可变的键值对集合，用于存储关联关系。

这些序列类型在Python中都具有重要的应用场景，可以用于存储和操作不同类型的数据。列表和元组通常用于存储一组有序的元素，字符串用于处理文本数据，集合用于去除重复元素和进行集合运算，而字典用于建立键值对关系，方便快速查找和访问数据。在实际应用中，我们会根据不同的需求选择合适的序列类型来处理数据。

以下是常用序列类型的详解示例：

1.1 字符串（String）

字符串由字符组成的序列，可以使用引号或双引号来表示。

my_string = "Hello, World!"
print(my_string)  # 输出：Hello, World!

1.2 列表（List）

由一系列元素组成，元素之间用逗号隔开，使用方括号表示。列表是可变的，可以添加、删除和修改其中的元素。

my_list = [1, 2, 3, 4, 5]
print(my_list)  # 输出：[1, 2, 3, 4, 5]

1.3 元组 (Tuple)

类似于列表，由一系列元素组成，但元组使用圆括号表示。元组是不可变的，一旦创建就不能更改其中的元素。

my_tuple = (10, 20, 30)
print(my_tuple)  # 输出：(10, 20, 30)

1.4 字典（Dictionary）

它是一个无序的、可变的集合，用于存储键值对（key-value pairs）。每个键（key）在字典中都是唯一的，而值（value）可以是任意类型的数据，包括基本数据类型（例如整数、浮点数、字符串）以及其他复杂的数据类型（例如列表、元组、字典等）。

字典的创建使用花括号 {}，每个键值对用冒号 : 分隔，多个键值对之间用逗号 , 分隔。例如：

# 创建一个空字典
empty_dict = {}
# 创建一个包含键值对的字典
student_scores = {'Alice': 85, 'Bob': 90, 'John': 78}
# 字典中的键可以是不同类型的数据
mixed_dict = {'name': 'John', 1: 'one', (1, 2): 'tuple'}

1.5 集合（Set）

集合是Python中的一种数据类型，它是无序的、可变的序列，其中的元素不会重复。集合用于存储唯一的元素，通常用于去除重复项或进行集合运算。集合的创建使用花括号 {} 或者使用set()函数，例如：

# 创建一个空集合
empty_set = set()
# 创建一个包含元素的集合
fruits = {'apple', 'orange', 'banana'}

2 序列的常用运算符

2.1 索引

在Python中，序列的索引用于访问序列中的特定元素。索引是一种通过整数值来定位序列中元素位置的方法，索引从0开始，依次递增。

也可以使用负数索引来从序列末尾开始计数，最后一个元素的索引为-1，倒数第二个元素的索引为-2，依此类推。

常见的序列类型（字符串、列表、元组、字节串等）都支持索引操作。使用方括号"[]"来指定索引，将索引值放在方括号内即可访问相应位置的元素。

以下是一些常用序列类型的索引示例：

# 字符串索引
my_string = "Hello, World!"
print(my_string[0])      # 输出：H
print(my_string[7])      # 输出：W
print(my_string[-1])     # 输出：!
# 列表索引
my_list = [10, 20, 30, 40, 50]
print(my_list[2])        # 输出：30
print(my_list[-3])       # 输出：30
# 元组索引
my_tuple = (100, 200, 300)
print(my_tuple[1])       # 输出：200
print(my_tuple[-2])      # 输出：200
# 字节串索引
my_bytes = b'\x48\x65\x6c\x6c\x6f'
print(my_bytes[0])       # 输出：72
print(my_bytes[-1])      # 输出：111

2.2 切片

在Python中，序列的切片是一种从序列中获取子序列的操作。

切片允许我们根据一定的规则选取序列中的一部分元素，并返回一个新的子序列。切片操作使用方括号"[]"和冒号":"来指定切片的起始位置、终止位置以及步长。

切片的语法为：sequence[start:stop:step]，其中：

start：切片的起始位置（包含在切片中），默认为0。
stop：切片的终止位置（不包含在切片中），默认为序列的长度。
step：切片中连续元素之间的步长，默认为1。

需要注意的是，切片操作不会修改原始序列，而是返回一个新的子序列。

以下是一些常用序列类型的切片操作示例：

# 字符串切片
my_string = "Hello, World!"
print(my_string[0:5])      # 输出：Hello
print(my_string[:5])       # 输出：Hello
print(my_string[7:])       # 输出：World!
print(my_string[::2])      # 输出：HloWrd
# 列表切片
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(my_list[1:6])        # 输出：[2, 3, 4, 5, 6]
print(my_list[:4])         # 输出：[1, 2, 3, 4]
print(my_list[::2])        # 输出：[1, 3, 5, 7, 9]
# 元组切片
my_tuple = (10, 20, 30, 40, 50)
print(my_tuple[1:4])       # 输出：(20, 30, 40)
print(my_tuple[::2])       # 输出：(10, 30, 50)
# 字节串切片
my_bytes = b'\x48\x65\x6c\x6c\x6f'
print(my_bytes[0:3])       # 输出：b'Hel'
print(my_bytes[::2])       # 输出：b'Hello'

2.3 连接和重复

在Python中，序列类型（如字符串、列表、元组、字节串等）支持连接和重复操作，这些操作允许我们将两个序列连接在一起，或将一个序列重复多次。

连接：

使用"+"运算符可以将两个序列连接在一起，生成一个新的序列，其中包含了两个序列的元素。

# 字符串连接
str1 = "Hello, "
str2 = "World!"
result_str = str1 + str2
print(result_str)  # 输出：Hello, World!
# 列表连接
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result_list = list1 + list2
print(result_list)  # 输出：[1, 2, 3, 4, 5, 6]
# 元组连接
tuple1 = (10, 20, 30)
tuple2 = (40, 50, 60)
result_tuple = tuple1 + tuple2
print(result_tuple)  # 输出：(10, 20, 30, 40, 50, 60)
# 字节串连接
bytes1 = b'Hello, '
bytes2 = b'World!'
result_bytes = bytes1 + bytes2
print(result_bytes)  # 输出：b'Hello, World!'

重复：使用"*"运算符可以将一个序列重复多次，生成一个新的序列。

示例：

# 字符串重复
str1 = "Hello, "
result_str = str1 * 3
print(result_str)  # 输出：Hello, Hello, Hello,
# 列表重复
list1 = [1, 2, 3]
result_list = list1 * 2
print(result_list)  # 输出：[1, 2, 3, 1, 2, 3]
# 元组重复
tuple1 = (10, 20)
result_tuple = tuple1 * 4
print(result_tuple)  # 输出：(10, 20, 10, 20, 10, 20, 10, 20)
# 字节串重复
bytes1 = b'Hello! '
result_bytes = bytes1 * 2
print(result_bytes)  # 输出：b'Hello! Hello! '

2.4 成员关系

在Python中，我们可以使用关键字"in"来检查序列中是否包含某个特定元素。这被称为成员关系操作，用于判断一个元素是否是某个序列的成员。

成员关系操作返回一个布尔值，如果序列中包含给定元素，则返回True，否则返回False。

以下是成员关系操作的示例：

# 字符串成员关系
my_string = "Hello, World!"
print('H' in my_string)      # 输出：True
print('e' in my_string)      # 输出：True
print('X' in my_string)      # 输出：False
# 列表成员关系
my_list = [1, 2, 3, 4, 5]
print(3 in my_list)          # 输出：True
print(6 in my_list)          # 输出：False
# 元组成员关系
my_tuple = (10, 20, 30)
print(20 in my_tuple)        # 输出：True
print(40 in my_tuple)        # 输出：False
# 字节串成员关系
my_bytes = b'\x48\x65\x6c\x6c\x6f'
print(b'H' in my_bytes)      # 输出：True
print(b'X' in my_bytes)      # 输出：False

2.5 长度

可以使用内置函数len()来获取序列的长度，即序列中包含的元素个数。len()函数适用于字符串、列表、元组、字节串等序列类型。

# 字符串长度
my_string = "Hello, World!"
print(len(my_string))  # 输出：13
# 列表长度
my_list = [1, 2, 3, 4, 5]
print(len(my_list))    # 输出：5
# 元组长度
my_tuple = (10, 20, 30)
print(len(my_tuple))   # 输出：3
# 字节串长度
my_bytes = b'\x48\x65\x6c\x6c\x6f'
print(len(my_bytes))   # 输出：5

2.6 最值

可以使用内置函数 min() 和 max() 来获取序列中的最小值和最大值。

以下是获取序列最值的示例：

# 字符串最值
my_string = "Hello, World!"
print(min(my_string))  # 输出：空格字符 ' '
print(max(my_string))  # 输出：字母 'r'
# 列表最值
my_list = [1, 2, 3, 4, 5]
print(min(my_list))    # 输出：1
print(max(my_list))    # 输出：5
# 元组最值
my_tuple = (10, 20, 30)
print(min(my_tuple))   # 输出：10
print(max(my_tuple))   # 输出：30
# 字节串最值
my_bytes = b'\x48\x65\x6c\x6c\x6f'
print(min(my_bytes))   # 输出：72，即 ASCII 码值为 72 的字符 'H'
print(max(my_bytes))   # 输出：111，即 ASCII 码值为 111 的字符 'o'

2.7 迭代（遍历）

序列的迭代是处理序列数据的常用方式之一。通过迭代，我们可以遍历整个序列，对其中的每个元素进行处理或执行相应的操作。

以下是序列的迭代示例：

# 字符串迭代
my_string = "Hello, World!"
for char in my_string:
    print(char)  # 逐个输出字符串中的字符
# 列表迭代
my_list = [1, 2, 3, 4, 5]
for num in my_list:
    print(num)  # 逐个输出列表中的元素
# 元组迭代
my_tuple = (10, 20, 30)
for item in my_tuple:
    print(item)  # 逐个输出元组中的元素
# 字节串迭代
my_bytes = b'\x48\x65\x6c\x6c\x6f'
for byte in my_bytes:
    print(byte)  # 逐个输出字节串中的字节值（整数）

上述示例中，我们使用for循环迭代了不同类型的序列，逐个输出了序列中的元素（字符或整数）。在每次循环中，迭代变量会依次取得序列中的每个元素，然后执行循环体内的操作。

2.8 反转

可以使用 reversed() 函数来反转序列。reversed() 函数返回一个反向迭代器，该迭代器可以用于按照相反的顺序遍历序列中的元素。需要注意的是，reversed() 函数不会修改原始序列，而是返回一个新的迭代器对象。

以下是对序列进行反转的示例：

# 字符串反转
my_string = "Hello, World!"
reversed_string = ''.join(reversed(my_string))
print(reversed_string)  # 输出：!dlroW ,olleH
# 列表反转
my_list = [1, 2, 3, 4, 5]
reversed_list = list(reversed(my_list))
print(reversed_list)    # 输出：[5, 4, 3, 2, 1]
# 元组反转
my_tuple = (10, 20, 30)
reversed_tuple = tuple(reversed(my_tuple))
print(reversed_tuple)   # 输出：(30, 20, 10)
# 字节串反转
my_bytes = b'\x48\x65\x6c\x6c\x6f'
reversed_bytes = bytes(reversed(my_bytes))
print(reversed_bytes)   # 输出：b'olloH'

在上述示例中，我们使用 reversed() 函数来反转了不同类型的序列，得到了新的反转后的序列对象。需要注意的是，如果想要获取反转后的序列作为一个新的序列，需要使用 list() 函数（对于列表、元组、字节串）或 bytes() 函数（对于字节串）将反转后的迭代器转换为相应的序列类型。

2.9 排序

可以使用 sorted() 函数对序列进行排序。sorted() 函数返回一个新的排序后的列表（对于列表、元组和字符串）或排序后的字节串（对于字节串），而不会修改原始序列。

sorted() 函数可以用于任何序列类型，并且可以按升序或降序排序。默认情况下，它按升序对序列进行排序，但也可以通过 reverse=True 参数指定降序排序。

以下是对序列进行排序的示例：

# 列表排序（升序）
my_list = [5, 2, 8, 1, 3]
sorted_list = sorted(my_list)
print(sorted_list)   # 输出：[1, 2, 3, 5, 8]
# 列表排序（降序）
my_list = [5, 2, 8, 1, 3]
sorted_list_desc = sorted(my_list, reverse=True)
print(sorted_list_desc)   # 输出：[8, 5, 3, 2, 1]
# 字符串排序
my_string = "hello"
sorted_string = ''.join(sorted(my_string))
print(sorted_string)   # 输出：ehllo
# 字节串排序（升序）
my_bytes = b'\x68\x65\x6c\x6c\x6f'
sorted_bytes = bytes(sorted(my_bytes))
print(sorted_bytes)   # 输出：b'ehllo'
# 元组排序
my_tuple = (10, 5, 20, 15)
sorted_tuple = tuple(sorted(my_tuple))
print(sorted_tuple)   # 输出：(5, 10, 15, 20)

2.10 判断是否为空

在Python中，我们可以使用条件判断语句来检查一个序列是否为空。为空的序列是指没有包含任何元素的序列，例如空字符串、空列表、空元组、空字节串等。

判断一个序列是否为空可以使用以下方法：

（1）使用len()函数判断长度是否为0，长度为0表示序列为空

my_string = ""
my_list = []
my_tuple = ()
my_bytes = b''
if len(my_string) == 0:
    print("字符串为空")
if len(my_list) == 0:
    print("列表为空")
if len(my_tuple) == 0:
    print("元组为空")
if len(my_bytes) == 0:
    print("字节串为空")

（2）使用条件表达式进行判断。（使用not关键字判断序列是否为空）

if not my_string:
    print("字符串为空")
if not my_list:
    print("列表为空")
if not my_tuple:
    print("元组为空")
if not my_bytes:
    print("字节串为空")

无论使用哪种方法，当序列为空时，条件判断将会为True，进入相应的判断语句中。

注意，空序列的布尔值为False，所以可以直接在条件语句中使用序列对象进行判断。

2.11 修改元素

可以通过索引和切片来修改可变序列（如列表和字节数组）中的元素。不可变序列（如字符串和元组）是无法直接修改其中的元素的，但可以通过创建一个新的序列来间接实现。

下面分别演示如何修改可变序列和不可变序列中的元素：

（1）修改可变序列（列表）中的元素：

my_list = [10, 20, 30, 40, 50]
# 修改单个元素
my_list[2] = 35
print(my_list)  # 输出：[10, 20, 35, 40, 50]
# 使用切片修改多个元素
my_list[1:4] = [15, 25, 45]
print(my_list)  # 输出：[10, 15, 25, 45, 50]
# 使用切片删除元素
my_list[2:4] = []
print(my_list)  # 输出：[10, 15, 50]

注意：列表和字节数组都是可变序列，可以直接通过索引或切片来修改其中的元素或删除元素。

（2）修改不可变序列（字符串）中的元素（间接实现）：

my_string = "Hello, World!"
# 字符串是不可变序列，无法直接修改其中的元素
# 可以通过切片和字符串拼接来间接实现
my_string = my_string[:7] + 'Python!'
print(my_string)  # 输出：Hello, Python!

注意：字符串和元组是不可变序列，无法直接修改其中的元素，但可以通过切片等操作来创建一个新的序列，并实现修改或拼接的效果。

总结：对于可变序列，可以直接通过索引和切片来修改和删除元素；对于不可变序列，无法直接修改其中的元素，但可以通过切片等方式创建一个新的序列来间接实现修改。

2.12 添加元素

在Python中，可以使用各种方法向可变序列（如列表和字节数组）中添加新的元素。不可变序列（如字符串和元组）无法直接添加新的元素，但可以通过创建一个新的序列来间接实现。

A 以下是向可变序列中添加元素的示例：

注意：列表和字节数组都是可变序列，可以使用append()、extend()和insert()等方法来向序列中添加元素。

（1）向列表中添加元素：

my_list = [10, 20, 30]
# 使用append()方法在末尾添加元素
my_list.append(40)
print(my_list)  # 输出：[10, 20, 30, 40]
# 使用extend()方法将另一个可迭代对象中的元素添加到末尾
my_list.extend([50, 60])
print(my_list)  # 输出：[10, 20, 30, 40, 50, 60]
# 使用insert()方法在指定位置插入元素
my_list.insert(1, 15)  # 在索引为1的位置插入元素15
print(my_list)  # 输出：[10, 15, 20, 30, 40, 50, 60]

（2）向字节数组中添加元素：

my_bytes = bytearray(b'\x48\x65\x6c')
# 使用append()方法在末尾添加字节
my_bytes.append(0x6f)
print(my_bytes)  # 输出：bytearray(b'Hello')
# 使用extend()方法将另一个字节数组中的字节添加到末尾
my_bytes.extend(b'!')
print(my_bytes)  # 输出：bytearray(b'Hello!')
# 使用insert()方法在指定位置插入字节
my_bytes.insert(5, 0x2c)  # 在索引为5的位置插入字节0x2c（逗号）
print(my_bytes)  # 输出：bytearray(b'Hello,!')

B 对于不可变序列（如字符串和元组），无法直接添加新的元素，但可以通过切片和拼接的方式来创建一个新的序列，从而实现添加元素的效果：

(1)向字符串中添加元素：

my_string = "Hello"
# 使用切片和字符串拼接来添加元素
my_string = my_string + " World!"
print(my_string)  # 输出：Hello World!

(2)向元组中添加元素：

my_tuple = (10, 20, 30)
# 使用切片和元组拼接来添加元素
my_tuple = my_tuple + (40, 50)
print(my_tuple)  # 输出：(10, 20, 30, 40, 50)

C 总结：

对于可变序列，可以使用append()、extend()和insert()等方法来直接添加元素；对于不可变序列，无法直接添加元素，但可以通过切片和拼接的方式创建一个新的序列来间接实现添加。

2.13 删除元素

与添加元素操作一样，可以使用各种方法删除可变序列（如列表和字节数组）中的元素。不可变序列（如字符串和元组）是无法直接删除其中的元素的，但可以通过创建一个新的序列来间接实现删除

A 以下是删除可变序列中元素的示例：

列表和字节数组都是可变序列，可以使用del语句、remove()和pop()等方法来删除元素。

（1）从列表中删除元素：

my_list = [10, 20, 30, 40, 50]
# 使用del语句删除指定索引位置的元素
del my_list[2]
print(my_list)  # 输出：[10, 20, 40, 50]
# 使用remove()方法删除指定值的元素（仅删除第一个匹配的元素）
my_list.remove(20)
print(my_list)  # 输出：[10, 40, 50]
# 使用pop()方法删除指定索引位置的元素，并返回该元素的值
popped_value = my_list.pop(1)
print(my_list)      # 输出：[10, 50]
print(popped_value)  # 输出：40

（2）从字节数组中删除元素：

my_bytes = bytearray(b'\x48\x65\x6c\x6c\x6f')
# 使用del语句删除指定索引位置的字节
del my_bytes[1]
print(my_bytes)  # 输出：bytearray(b'Hllo')
# 使用remove()方法删除指定值的字节（仅删除第一个匹配的字节）
my_bytes.remove(0x6c)
print(my_bytes)  # 输出：bytearray(b'Hlo')
# 使用pop()方法删除指定索引位置的字节，并返回该字节的值
popped_byte = my_bytes.pop(2)
print(my_bytes)    # 输出：bytearray(b'Hl')
print(popped_byte)  # 输出：108（即字节0x6c）

B 对于不可变序列（如字符串和元组），无法直接删除其中的元素，但可以通过切片和拼接的方式创建一个新的序列，从而实现删除元素的效果：

（1）从字符串中删除元素：

my_string = "Hello, World!"
# 使用切片和字符串拼接来删除元素
my_string = my_string[:5] + my_string[7:]
print(my_string)  # 输出：Hello World!

（2）从元组中删除元素：

my_tuple = (10, 20, 30, 40, 50)
# 使用切片和元组拼接来删除元素
my_tuple = my_tuple[:2] + my_tuple[3:]
print(my_tuple)  # 输出：(10, 20, 40, 50)

C 总结

对于可变序列，可以使用del语句、remove()和pop()等方法来直接删除元素；对于不可变序列，无法直接删除元素，但可以通过切片和拼接的方式创建一个新的序列来间接实现删除。

2.14 查找元素

在Python中，可以使用不同的方法来查找序列中的元素。具体的方法取决于序列的类型和需要查找的条件。以下是一些常用的元素查找方法：

（1）索引查找：使用索引可以直接查找序列中的元素。索引是从0开始的整数，可以使用正数索引（从前往后）或负数索引（从后往前）访问序列中的元素。

示例：

my_list = [10, 20, 30, 40, 50]
print(my_list[2])   # 输出：30
print(my_list[-1])  # 输出：50

（2）in关键字查找：使用in关键字可以判断某个元素是否在序列中。

示例：

my_string = "Hello, World!"
print('o' in my_string)      # 输出：True
print('X' in my_string)      # 输出：False

（3）index()方法查找： 对于不可变序列（如字符串和元组），可以使用index()方法来查找指定元素在序列中的索引。如果找不到该元素，会引发ValueError异常。

示例：

my_string = "Hello, World!"
print(my_string.index('e'))  # 输出：1
print(my_string.index('X'))  # 抛出 ValueError: substring not found

（4）count()方法查找：使用count()方法可以统计指定元素在序列中出现的次数。

示例：

my_list = [1, 2, 2, 3, 2, 4, 5]
print(my_list.count(2))  # 输出：3

以上这些方法可以帮助我们在序列中查找指定的元素。注意，

对于不可变序列（如字符串和元组），查找方法主要是通过index()方法进行，

对于可变序列（如列表和字节数组），使用索引、in关键字、count()方法等进行查找。

2.15 元素计数

在Python中，可以使用count()方法来统计序列中指定元素出现的次数。count()方法适用于各种序列类型，包括字符串、列表、元组、字节串等。它返回指定元素在序列中出现的次数。

以下是使用count()方法计数元素出现次数的示例：

# 字符串计数元素
my_string = "Hello, World!"
print(my_string.count('l'))  # 输出：3，统计字母'l'在字符串中出现的次数
# 列表计数元素
my_list = [1, 2, 2, 3, 2, 4, 5]
print(my_list.count(2))      # 输出：3，统计数字2在列表中出现的次数
# 元组计数元素
my_tuple = (10, 20, 30, 20, 40, 20, 50)
print(my_tuple.count(20))    # 输出：3，统计数字20在元组中出现的次数
# 字节串计数元素
my_bytes = b'\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21'
print(my_bytes.count(b'l'))  # 输出：3，统计字节0x6c（ASCII值为108）在字节串中出现的次数

在上述示例中，我们使用count()方法分别计数了不同类型序列中指定元素的出现次数。count()方法对于统计元素出现的频次非常有用，可以在数据处理和算法设计中提供便利。

总结：

序列是Python中重要且常用的数据类型，提供了许多常用运算符。以下是序列的一些常用操作：

索引和切片：使用索引可以访问序列中的单个元素，使用切片可以获取子序列。
长度：使用len()函数可以获取序列的长度，即序列中元素的个数。
迭代：使用for循环可以遍历序列中的每个元素。
成员关系：使用in关键字可以判断某个元素是否在序列中。
连接：使用"+"运算符可以将两个序列连接在一起，生成一个新的序列。
重复：使用"*"运算符可以将一个序列重复多次，生成一个新的序列。
排序：使用sorted()函数可以对序列进行排序，生成一个新的排序后的序列。
添加元素：对于可变序列（如列表和字节数组），可以使用append()、extend()和insert()等方法来添加新的元素。
删除元素：对于可变序列（如列表和字节数组），可以使用del语句、remove()和pop()等方法来删除元素。
序列判断：使用条件判断可以检查一个序列是否为空。
元素查找：对于不可变序列（如字符串和元组），可以使用index()方法来查找指定元素在序列中的索引。
计数元素：使用count()方法可以统计指定元素在序列中出现的次数。

这些操作可以对序列进行各种处理和操作，满足不同场景下的需求。需要注意的是，不同类型的序列可能支持不同的操作，例如字符串和元组是不可变序列，无法直接修改其中的元素。对于可变序列，可以进行修改和删除操作。

3 序列的应用总结

序列是Python中非常重要和常用的数据类型，广泛应用于各种编程场景。以下是序列的应用总结：

存储和处理数据：序列可以用于存储和处理各种类型的数据，包括整数、浮点数、字符串、自定义对象等。通过序列的索引、切片、迭代等操作，可以方便地访问和处理数据。
文本处理：字符串是一种特殊的序列，常用于文本处理、字符串匹配、替换等操作。Python中有丰富的字符串处理方法，使得文本处理变得非常便捷。
列表操作：列表是最常用的序列类型之一，可以用于存储动态数据集合，进行增删改查等操作，是一种灵活的数据结构。
排序和搜索：序列的排序操作是常用的算法之一。可以使用sorted()函数对序列进行排序，也可以使用sort()方法对可变序列进行原地排序。此外，也可以使用index()方法进行搜索元素的位置。
数据统计：序列提供了count()方法用于统计元素出现的次数，非常有用于数据统计和分析。
数据连接和重复：序列的连接和重复操作可以将多个序列合并成一个新的序列，或者将一个序列复制多次，非常方便。
数据过滤和筛选：序列的切片操作可以用于从序列中抽取子序列，实现数据的过滤和筛选。
序列的特性：序列有多种特性，如有序性、可迭代性、混合元素类型、长度可变性等，这些特性使得序列成为灵活且功能强大的数据类型。

总的来说，序列是Python编程中不可或缺的数据类型，它的强大功能和易用性使得数据处理、算法设计、文本处理等方面变得更加简便。熟练掌握序列的操作和应用，对于Python编程是非常重要的。

【100天精通python】Day6：python基础_基本数据结构，常用序列类型和运算符

1 常用的序列类型

1.1 字符串（String）

1.2 列表（List）

1.3 元组 (Tuple)

1.4 字典（Dictionary）

1.5 集合（Set）

2 序列的常用运算符

2.1 索引

2.2 切片

2.3 连接和重复

2.4 成员关系

2.5 长度

2.6 最值

2.7 迭代（遍历）

2.8 反转

2.9 排序

2.10 判断是否为空

（1）使用len()函数判断长度是否为0，长度为0表示序列为空

（2）使用条件表达式进行判断。（使用not关键字判断序列是否为空）

2.11 修改元素

（1）修改可变序列（列表）中的元素：

（2）修改不可变序列（字符串）中的元素（间接实现）：

2.12 添加元素

（1）向列表中添加元素：

（2）向字节数组中添加元素：

2.13 删除元素

（1）从列表中删除元素：

2.14 查找元素

2.15 元素计数

3 序列的应用总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【100天精通python】Day6：python基础_基本数据结构，常用序列类型和运算符

1 常用的序列类型

1.1 字符串（String）

1.2 列表（List）

1.3 元组 (Tuple)

1.4 字典（Dictionary）

1.5 集合（Set）

2 序列的常用运算符

2.1 索引

2.2 切片

2.3 连接和重复

2.4 成员关系

2.5 长度

2.6 最值

2.7 迭代（遍历）

2.8 反转

2.9 排序

2.10 判断是否为空

（1） 使用len()函数判断长度是否为0，长度为0表示序列为空

（2）使用条件表达式进行判断。（使用not关键字判断序列是否为空）

2.11 修改元素

（1）修改可变序列（列表）中的元素：

（2）修改不可变序列（字符串）中的元素（间接实现）：

2.12 添加元素

（1）向列表中添加元素：

（2）向字节数组中添加元素：

2.13 删除元素

（1）从列表中删除元素：

2.14 查找元素

2.15 元素计数

3 序列的应用总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

（1）使用len()函数判断长度是否为0，长度为0表示序列为空