✍️
Shuang’s blog/
🐍
Python学习笔记-序列
Search
Python学习笔记-序列
🐍

Python学习笔记-序列

Tags
Computer Science
Tech
Published
February 19, 2024
Author
Shuang Tian
序列是指一种有序的数据集合，其中的元素按照一定顺序排列，并且可以通过索引访问其中的元素。Python中常见的序列类型包括列表（list）、元组（tuple）、字符串（string）、范围（range）、字节数组（bytearray）、字节序列（bytes）等。
  1. 序列类型
      2. 1.1 列表（List）：
      • 列表是Python中最常用的序列类型之一，使用方括号[]来表示，元素之间用逗号分隔。
      • 列表中的元素可以是不同类型的数据，也可以是嵌套的列表。
      • 列表是可变的（mutable），即可以通过索引进行访问、修改、添加和删除元素。
      my_list = [1, 2, 3, 'a', 'b', 'c']
      1.2 元组（Tuple）：
      • 元组与列表类似，但是元组使用圆括号()来表示。
      • 元组中的元素可以是不同类型的数据，也可以是嵌套的元组。
      • 元组是不可变的（immutable），即不能修改其中的元素。
      my_tuple = (1, 2, 3, 'a', 'b', 'c')
      1.3 字符串（String）：
      • 字符串是一种特殊的序列，由字符组成，使用单引号' '或双引号" "来表示。
      • 字符串是不可变的（immutable），即不能修改其中的字符。
      my_string = "Hello, World!"
      1.4 范围（Range）：
      • 范围是一种表示数字序列的对象，通常用于迭代。
      • 范围对象使用range()函数创建。
      my_range = range(5)  # 表示从0到4的整数序列
      1.5 字节数组（Bytearray）和字节序列（Bytes）：
      • 字节数组和字节序列都用来表示二进制数据的序列。
      • 字节数组是可变的，而字节序列是不可变的。
      my_bytearray = bytearray(b'hello')
my_bytes = b'hello'
      以上序列类型都支持一系列的通用操作，如索引、切片、迭代等
  1. 转换
      2. 在 Python 中，可以使用以下方法在序列中的列表、元组和字符串之间相互转换：
    1. 列表（List）转换为元组（Tuple）：
        • 使用 tuple() 函数将列表转换为元组。
        my_list = [1, 2, 3]
my_tuple = tuple(my_list)
    2. 元组转换为列表：
        • 使用 list() 函数将元组转换为列表。
        my_tuple = (1, 2, 3)
my_list = list(my_tuple)
    3. 字符串转换为列表：
        • 使用字符串的 split() 方法将字符串按照指定的分隔符拆分为列表。
        my_string = "hello world"
my_list = my_string.split()  # 默认以空格为分隔符
    4. 列表转换为字符串：
        • 使用字符串的 join() 方法将列表中的元素连接为一个字符串。
        pythonCopy code
my_list = ['hello', 'world']
my_string = ' '.join(my_list)  # 使用空格连接列表中的元素
    5. 元组转换为字符串：
        • 首先将元组转换为列表，然后使用列表转换为字符串的方法。
        my_tuple = (1, 2, 3)
my_list = list(my_tuple)
my_string = ' '.join(map(str, my_list))
    6. 字符串转换为元组：
        • 使用 tuple() 函数将字符串中的每个字符转换为元组的一个元素。
            • my_string = "hello"
my_tuple = tuple(my_string)
    7. 列表和元组转换为字符串 str() 函数将列表和元组转换为字符串。当你调用 str() 函数并传入一个列表或元组作为参数时，它会返回一个表示该列表或元组的字符串，其中包含了列表或元组中的元素。
        8. my_list = [1, 2, 3]
my_tuple = (4, 5, 6)

str_from_list = str(my_list)
str_from_tuple = str(my_tuple)

print(str_from_list)   # 输出 '[1, 2, 3]'
print(str_from_tuple)  # 输出 '(4, 5, 6)'
        注意，使用 str() 函数将列表或元组转换为字符串时，结果字符串中会包含方括号 [...]（对于列表）或圆括号 (...)（对于元组），并且元素之间用逗号 , 分隔。
        需要注意的是，这种方法仅仅是将列表或元组的外观转换为字符串形式，而不是将列表或元组的元素逐个转换为字符串并拼接起来。如果你想将列表或元组中的元素逐个转换为字符串并拼接起来，可以使用 join() 方法。
  1. is 和 is not 是用于比较对象身份的运算符，而不是用于比较对象的值。这两个运算符用于检查两个对象是否指向同一个内存地址。下面是关于这两个操作符的详细介绍：
    1. is 操作符：
      • is 操作符用于检查两个对象是否是同一个对象，即它们是否共享相同的内存地址。
      • 如果两个对象是同一个对象，则返回 True，否则返回 False。
      • is 操作符在比较时不会调用对象的 __eq__() 方法，而是直接比较对象的内存地址。
      a = [1, 2, 3]
b = a  # b和a指向同一个列表对象
c = [1, 2, 3]  # c是另一个列表对象，虽然内容相同但地址不同
print(a is b)  # 输出 True
print(a is c)  # 输出 False
      b. is not 操作符：
      • is not 操作符是 is 的反义词，用于检查两个对象是否不是同一个对象。
      • 如果两个对象不是同一个对象，则返回 True，否则返回 False。
      a = [1, 2, 3]
b = [1, 2, 3]
print(a is not b)  # 输出 True，因为a和b不是同一个对象
      虽然is 和 is not 在某些情况下可以替代 == 和 != 运算符，但它们并不相同。== 和 != 运算符用于比较两个对象的值是否相等，而 is 和 is not 运算符用于比较两个对象的身份是否相同。
  1. 序列的操作
    1. 索引（Indexing）：
        • 使用索引访问序列中的单个元素。
        • 格式为 sequence[index]，其中 sequence 是序列，index 是要访问的元素的位置，索引从0开始。
    2. 切片（Slicing）：
        • 使用切片操作从序列中获取子序列。
        • 格式为 sequence[start:stop:step]，其中 start 是起始索引，stop 是结束索引（不包含），step 是步长。
    3. 长度（Length）：
        • 使用 len() 函数获取序列的长度，即其中元素的个数。
    4. 成员关系（Membership）：
        • 使用 in 和 not in 运算符检查某个元素是否存在于序列中。
    5. 最大值和最小值（Max and Min）：
        • 使用 max() 和 min() 函数获取序列中的最大值和最小值。
    6. 连接（Concatenation）：
        • 使用 + 运算符将两个序列连接起来，生成一个新的序列。
    7. 重复（Repetition）：
        • 使用 运算符将序列重复多次，生成一个新的序列。
    8. 迭代（Iteration）：
        • 使用 for 循环遍历序列中的每个元素。
    9. 添加元素（Adding Elements）：
        • 对于可变序列，可以使用 append()、insert() 等方法向序列中添加新元素。
    10. 删除元素（Removing Elements）：
        • 对于可变序列，可以使用 pop()、remove() 等方法删除序列中的元素。
    11. 排序（Sorting）：
        • 使用 sorted() 函数对序列进行排序，生成一个新的有序序列。
    12. 反转（Reversing）：
        • 使用 reversed() 函数或切片操作 [::-1] 反转序列中的元素顺序，生成一个新的序列。返回结果为参数的反向迭代器。
    13. 统计（Counting）：
        • 使用 count() 方法统计序列中某个元素出现的次数。
    14. 查找（Searching）：
        • 使用 index() 方法查找某个元素在序列中第一次出现的位置索引。
    15. 空序列判断（Empty Sequence Check）：
        • 使用 not 运算符或者 len() 函数判断序列是否为空。
      # 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 索引操作
print("Indexing example:", my_list[0])  # 输出第一个元素，结果为 1

# 切片操作
print("Slicing example:", my_list[1:4])  # 输出索引1到3的子序列，结果为 [2, 3, 4]

# 长度操作
print("Length example:", len(my_list))  # 输出列表长度，结果为 5

# 成员关系操作
print("Membership example:", 6 in my_list)  # 检查元素 6 是否在列表中，结果为 False

# 最大值和最小值操作
print("Max and Min example:", max(my_list), min(my_list))  # 输出列表的最大值和最小值，结果为 5 和 1

# 连接操作
new_list = my_list + [6, 7]
print("Concatenation example:", new_list)  # 输出连接后的新列表，结果为 [1, 2, 3, 4, 5, 6, 7]

# 重复操作
repeated_list = my_list * 2
print("Repetition example:", repeated_list)  # 输出重复两次的列表，结果为 [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

# 迭代操作
print("Iteration example:")
for item in my_list:
    print(item)  # 遍历并输出列表中的每个元素

# 添加元素操作
my_list.append(6)
print("Adding Elements example:", my_list)  # 输出添加元素后的列表，结果为 [1, 2, 3, 4, 5, 6]

# 删除元素操作
my_list.remove(6)
print("Removing Elements example:", my_list)  # 输出删除元素后的列表，结果为 [1, 2, 3, 4, 5]

# 排序操作
sorted_list = sorted(my_list)
print("Sorting example:", sorted_list)  # 输出排序后的列表，结果为 [1, 2, 3, 4, 5]

# 反转操作
reversed_list = list(reversed(my_list))
print("Reversing example:", reversed_list)  # 输出反转后的列表，结果为 [5, 4, 3, 2, 1]，返回结果为参数的反向迭代器

# 统计操作
count = my_list.count(3)
print("Counting example:", count)  # 统计元素 3 在列表中出现的次数，结果为 1

# 查找操作
index = my_list.index(4)
print("Searching example:", index)  # 查找元素 4 在列表中的索引位置，结果为 3

# 空序列判断操作
empty_list = []
print("Empty Sequence Check example:", not empty_list)  # 判断列表是否为空，结果为 True
  1. all() 和 any() 是 Python 内置函数，用于对可迭代对象进行逻辑判断，返回布尔值。
      2. all() 函数：
      • all() 函数接受一个可迭代对象作为参数，如列表、元组、集合等。
      • 如果可迭代对象中的所有元素都为真值（非零、非空、非 None 等），则返回 True，否则返回 False。
      • 如果可迭代对象为空，则 all() 返回 True。
      any() 函数：
      • any() 函数也接受一个可迭代对象作为参数。
      • 如果可迭代对象中的任何一个元素为真值，则返回 True，否则返回 False。
      • 如果可迭代对象为空，则 any() 返回 False。
      这两个函数在逻辑判断时非常有用，可以快速判断可迭代对象中的元素是否满足特定条件。all() 函数用于检查所有元素是否为真，而 any() 函数用于检查是否存在至少一个真元素。
      # all()函数
my_list = [True, True, False]
print(all(my_list))  # 输出 False，因为有一个元素为 False

my_tuple = (1, 2, 3, 4)
print(all(my_tuple))  # 输出 True，因为所有元素都为非零值

# any()函数
my_list = [False, False, True]
print(any(my_list))  # 输出 True，因为有一个元素为 True

my_tuple = (0, '', None, False)
print(any(my_tuple))  # 输出 False，因为所有元素都为假值
  1. enumerate() 函数是 Python 内置函数之一，用于将一个可迭代对象组合为一个索引序列，同时返回索引和对应的值。它的作用是在迭代过程中同时获得元素索引和值，通常在需要遍历序列并需要知道当前元素索引的情况下使用。
      2. enumerate() 函数的语法如下：
      enumerate(iterable, start=0)
      参数说明：
      • iterable：要进行枚举的可迭代对象，如列表、元组、字符串等。
      • start：可选参数，指定起始的索引值，默认为 0。
      enumerate() 函数返回一个枚举对象，每个元素都是一个元组，包含两个值，第一个值是索引，第二个值是对应的元素值。
      示例：
      my_list = ['a', 'b', 'c', 'd']

for index, value in enumerate(my_list):
    print(index, value)

# 输出结果为
0 a
1 b
2 c
3 d
      在这个示例中，enumerate() 函数将列表 my_list 中的元素和对应的索引进行了配对，并在每次迭代时返回一个包含索引和值的元组。在循环体中，分别将索引和值赋值给 index 和 value，然后将它们打印出来。
      此外，还可以通过指定 start 参数来指定起始的索引值。例如：
      for index, value in enumerate(my_list, start=1):
    print(index, value)

#输出结果为

1 a
2 b
3 c
4 d
  1. zip() 函数是 Python 内置函数之一，用于将多个可迭代对象（例如列表、元组等）中的对应元素打包成元组，并返回一个新的迭代器。它的作用是将多个序列“拉链”在一起，将每个序列中相同位置的元素组合成一个元组。
      2. zip() 函数的语法如下：
      pythonCopy code
zip(*iterables)
      参数说明：
      • iterables：可变数量的可迭代对象，可以是列表、元组等。
      zip() 函数返回一个迭代器，每次迭代会返回一个元组，其中包含了所有传入序列中相同位置的元素。
      下面是一个简单的示例：
      pythonCopy code
list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]

zipped = zip(list1, list2)

for item in zipped:
    print(item)
      输出结果为：
      ('a', 1)
('b', 2)
('c', 3)
      在这个示例中，zip() 函数将两个列表 list1 和 list2 中的元素一一配对，生成了一个迭代器 zipped。在每次迭代中，zip() 函数返回一个包含了两个列表中相同位置元素的元组，并将这些元组依次打印出来。
      需要注意的是，如果传入的序列长度不一致，则 zip() 函数会以最短的序列长度为准，超出部分的元素会被忽略。例如：
      list1 = ['a', 'b', 'c']
list2 = [1, 2]

zipped = zip(list1, list2)

for item in zipped:
    print(item)
      输出结果为：
      ('a', 1)
('b', 2)
      在这个示例中，list2 的长度比 list1 小，因此在迭代过程中，多余的元素 'c' 被忽略了。
      zip() 函数的返回值是一个迭代器，可以通过 list() 函数将其转换为列表，或者通过其他方式进行处理。
  1. ap() 函数用于对可迭代对象中的每个元素应用指定的函数，返回一个将函数应用于所有可迭代对象中相同位置元素的结果的迭代器。它的作用是将函数应用于可迭代对象中的每个元素，并返回一个包含了所有结果的迭代器。
      2. map() 函数的语法如下：
      map(function, iterable1, iterable2, ...)
      参数说明：
      • function：要应用于每个元素的函数。
      • iterable1, iterable2, ...：一个或多个可迭代对象，可以是列表、元组等。
      map() 函数返回一个迭代器，每次迭代时都会将指定函数应用于传入的每个可迭代对象中相同位置的元素，并返回结果。
      下面是一个简单的示例：
      # 定义一个函数，用于计算平方
def square(x):
    return x ** 2

# 使用map()函数将函数应用于列表中的每个元素
my_list = [1, 2, 3, 4, 5]
result = map(square, my_list)

# 将结果转换为列表并打印
print(list(result))
      输出结果为：
      [1, 4, 9, 16, 25]
      在这个示例中，square() 函数用于计算传入值的平方。然后，map() 函数将 square() 函数应用于列表 my_list 中的每个元素，并返回一个迭代器。最后，通过将结果转换为列表，我们得到了包含了每个元素的平方的列表。
      需要注意的是，如果传入 map() 函数的可迭代对象的长度不一致，则 map() 函数会以最短的长度为准，超出部分的元素会被忽略。
  1. filter() 函数是 Python 内置函数之一，用于过滤可迭代对象中的元素，根据指定函数的条件返回符合条件的元素，返回一个由符合条件的元素组成的迭代器。它的作用是根据指定的条件函数过滤出可迭代对象中符合条件的元素。filter() 函数的语法如下：
      2. filter(function, iterable)
      参数说明：
      • function：用于过滤元素的函数，该函数应返回 True 或 False。
      • iterable：可迭代对象，如列表、元组等。
      filter() 函数返回一个迭代器，每次迭代时都会将指定函数应用于传入的可迭代对象中的每个元素，并返回结果为 True 的元素。
      下面是一个简单的示例：
      # 定义一个函数，用于过滤奇数
def is_odd(x):
    return x % 2 != 0

# 使用filter()函数过滤列表中的奇数
my_list = [1, 2, 3, 4, 5]
result = filter(is_odd, my_list)

# 将结果转换为列表并打印
print(list(result))

# 输出结果为
[1, 3, 5]
      在这个示例中，is_odd() 函数用于判断传入的值是否为奇数。然后，filter() 函数将 is_odd() 函数应用于列表 my_list 中的每个元素，并返回一个迭代器。最后，通过将结果转换为列表，得到了包含了列表中奇数的列表。
      需要注意的是，如果指定函数返回 True 的元素将会被保留，而返回 False 的元素将会被过滤掉。
  1. 迭代器（iterator）和可迭代对象（iterable）是 Python 中与迭代（iteration）相关的重要概念。
      2. 可迭代对象（Iterable）： 可迭代对象是指实现了 __iter__() 方法的对象，或者实现了 __getitem__() 方法且其索引从0开始的对象。可迭代对象允许你使用迭代器来遍历其内部的元素。常见的可迭代对象包括列表（list）、元组（tuple）、字符串（string）、字典（dictionary）、集合（set）等。
      迭代器（Iterator）： 迭代器是指实现了 __iter__() 方法和 __next__() 方法的对象。迭代器通过调用 __next__() 方法逐个返回可迭代对象中的元素，当没有更多元素可供迭代时，抛出 StopIteration 异常。迭代器可以用于遍历可迭代对象，同时也可以用于表达式生成、惰性计算等场景。常见的迭代器包括生成器（generator）、文件对象、map()、filter()、zip() 等返回的迭代器。
      简而言之，可迭代对象是具有迭代能力的对象，而迭代器是用于遍历可迭代对象的工具。迭代器是可迭代对象的一种特殊形式，每次迭代都能产生下一个元素，直到迭代结束。在 Python 中，迭代器和可迭代对象为实现了迭代协议（Iteration Protocol）的对象提供了支持。
      在实际编程中，通常使用 for 循环来遍历可迭代对象，这时 Python 解释器会隐式地创建一个迭代器对象，并在迭代过程中调用其 __next__() 方法。例如：
      my_list = [1, 2, 3]
for item in my_list:
    print(item)
      在这个例子中，for 循环会隐式地创建一个迭代器对象，然后调用其 __next__() 方法逐个返回列表 my_list 中的元素。
  1. next() 是 Python 内置函数之一，用于从迭代器中获取下一个元素。它的作用是在迭代过程中逐个获取迭代器中的元素，直到迭代结束或者指定了默认值。
      2. next() 函数的语法如下：
      next(iterator, default)
      参数说明：
      • iterator：要获取下一个元素的迭代器。
      • default：可选参数，指定默认值。如果指定了默认值，并且迭代器已经到达末尾，则返回默认值；如果没有指定默认值，并且迭代器已经到达末尾，则抛出 StopIteration 异常。
      下面是一个简单的示例：
      # 创建一个迭代器
my_iterator = iter([1, 2, 3])

# 逐个获取迭代器中的元素
print(next(my_iterator))  # 输出 1
print(next(my_iterator))  # 输出 2
print(next(my_iterator))  # 输出 3

# 迭代已经结束，再次调用next()将会抛出StopIteration异常
# print(next(my_iterator))  # 会抛出 StopIteration 异常

# 指定默认值
print(next(my_iterator, "End"))  # 输出 "End"，因为迭代已经结束，返回了默认值
      在这个示例中，首先使用 iter() 函数将一个列表转换为迭代器，并将其赋值给变量 my_iterator。然后，使用 next() 函数逐个获取迭代器中的元素。在迭代结束后，再次调用 next() 函数会抛出 StopIteration 异常，除非指定了默认值，否则会返回默认值。
Copyright 2024 Shuang Tian