Python——序列及常见操作

序列

Python 中的序列（Sequence）是一种基础的数据结构，用于存储一系列的元素。这些元素之间可以通过索引（index）进行访问，索引通常是从 0 开始的。Python 中有几种内置的序列类型，它们各自拥有不同的特性和用途。主要的序列类型包括列表（List）、元组（Tuple）和字符串（String）。

1. 列表（List）

列表是 Python 中最常用的序列类型，它是一个可变的容器模型，可以存储任意类型的序列项，包括另一个列表。列表是可变的，意味着你可以添加、删除或修改列表中的元素。

2. 元组（Tuple）

元组与列表相似，但它是一个不可变的序列。一旦创建了元组，就不能修改它的内容（即不能添加、删除或更改其元素）。元组通常用于存储不应该改变的数据，例如函数的返回值。

3. 字符串（String）

字符串是 Python 中另一个重要的序列类型，用于表示文本数据。字符串是不可变的，这意味着一旦创建了字符串，就不能更改其中的字符。

变量的ID

在Python中，每个对象都有一个唯一的标识符（ID），这是对象在内存中的地址。当你使用id()函数时，它会返回对象的这个唯一标识符。需要注意的是，id()函数返回的是一个整数，它表示了对象在Python解释器内存中的位置（尽管这种解释并不完全准确，因为Python解释器可能会移动对象以优化内存使用，但在这个移动过程中，对象的ID会保持不变，直到对象被销毁并重新分配）。

变量本身并不存储数据，而是存储了对内存中某个对象的引用（或者说是对象的ID）。当你将一个变量赋值给另一个变量时，你实际上是在创建了一个新的引用，指向同一个对象。因此，这两个变量会有相同的id()值，因为它们都引用了同一个对象。

这里有一个简单的例子来说明这一点：

a = 10  
b = a  
  
print(id(a))  # 输出a的ID  
print(id(b))  # 输出b的ID，与a的ID相同，因为a和b都引用了同一个整数对象  
  
c = [1, 2, 3]  
d = c  
  
print(id(c))  # 输出c的ID  
print(id(d))  # 输出d的ID，与c的ID相同，因为c和d都引用了同一个列表对象  
  
# 修改列表对象本身不会影响其ID  
c.append(4)  
print(id(c))  # ID仍然相同，因为列表对象在内存中的位置没有改变  
print(id(d))  # ID也相同，因为d仍然引用着同一个列表对象  
  
# 但是，如果你将变量重新赋值为一个新的对象，其ID会改变  
a = 20  
print(id(a))  # 新的ID，因为a现在引用了一个新的整数对象

比较运算符is 和 is not 

在Python中，is 和 is not 是两个非常特殊的比较运算符，它们不是用来比较两个对象的值是否相等，而是用来比较两个对象是否是同一个对象（即，它们是否指向内存中的同一个位置）。

is 运算符

当两个变量或对象引用指向内存中的同一个对象时，使用 is 运算符比较它们的结果为 True。这通常用于检查对象是否为 None，或者两个变量是否引用了同一个不可变对象（尽管对于不可变对象，通常使用 == 来比较值更为常见）。

a = [1, 2, 3]  
b = a  
c = [1, 2, 3]  
  
print(a is b)  # 输出 True，因为a和b指向同一个列表对象  
print(a is c)  # 输出 False，因为a和c虽然内容相同，但指向不同的列表对象  
  
x = None  
y = None  
print(x is y)  # 输出 True，因为x和y都指向NoneType的同一个实例

is not 运算符

is not 是 is 的否定形式，用于检查两个对象是否不是同一个对象。如果两个变量或对象引用不指向内存中的同一个位置，则结果为 True。

a = [1, 2, 3]  
b = [1, 2, 3]  
  
print(a is not b)  # 输出 True，因为a和b虽然内容相同，但指向不同的列表对象  
  
x = None  
y = 42  
print(x is not y)  # 输出 True，因为x和y指向不同的对象

注意事项

• 对于可变对象（如列表、字典等），即使它们的内容相同，使用 is 比较时也可能返回 False，因为 is 关心的是对象的身份（即内存地址），而不是它们的值。
• 对于不可变对象（如整数、浮点数、字符串和元组），Python实现可能会进行一些小优化（如小整数池和字符串驻留），这意味着不同的字面量可能会指向内存中的同一个对象。因此，在某些情况下，即使两个不可变对象看起来不同，使用 is 比较时也可能返回 True。然而，这种情况通常仅限于小的整数和短的字符串。
• 在比较两个对象的值时，应该使用 == 而不是 is。== 运算符会调用对象的 __eq__ 方法（如果已定义）来比较两个对象的值是否相等。

关键字in 和 not in 

在Python中，in 和 not in 是两个非常有用的关键字，它们用于检查一个元素是否存在于某个序列（如列表、元组、字符串、集合或字典的键）中。

in

当你想要检查一个元素是否是一个序列（如列表、元组、字符串等）的成员时，你可以使用 in 关键字。如果元素存在于序列中，则表达式的结果为 True；否则为 False。

my_list = [1, 2, 3, 4, 5]  
print(3 in my_list)  # 输出 True，因为3在my_list中  
print('a' not in my_list)  # 注意这里我错误地使用了'a'作为示例，实际上应该单独检查  
  
my_string = "hello"  
print('l' in my_string)  # 输出 True，因为'l'在my_string中  
  
my_tuple = (1, 2, 3)  
print(2 in my_tuple)  # 输出 True，因为2在my_tuple中  
  
my_set = {1, 2, 3, 4}  
print(3 in my_set)  # 输出 True，因为3在my_set中  
  
# 字典的情况稍微有些不同，但你也可以检查键是否存在  
my_dict = {'a': 1, 'b': 2}  
print('a' in my_dict)  # 输出 True，因为'a'是my_dict的一个键

not in

not in 是 in 的否定形式。它用于检查一个元素是否不存在于某个序列中。如果元素不存在于序列中，则表达式的结果为 True；否则为 False。

my_list = [1, 2, 3, 4, 5]  
print(6 not in my_list)  # 输出 True，因为6不在my_list中  
  
my_string = "hello"  
print('w' not in my_string)  # 输出 True，因为'w'不在my_string中  
  
# 使用not in检查字典中的键  
my_dict = {'a': 1, 'b': 2}  
print('c' not in my_dict)  # 输出 True，因为'c'不是my_dict的一个键

in 和 not in 是Python中非常强大且常用的特性，它们使得在序列中查找元素变得简单而直接。

del语句

在Python中，del语句用于删除对象。它可以用来删除单个元素、切片、整个对象（比如列表、元组、字典、集合等，但需要注意的是，元组是不可变的，所以你不能使用del来删除元组中的元素，但你可以删除整个元组对象）。使用del时，Python会从内存中删除该对象的引用，如果这是对该对象的最后一个引用，那么该对象也会从内存中删除（即被垃圾回收）。

删除单个元素

在列表中，你可以使用del来删除指定位置的元素。

my_list = [1, 2, 3, 4, 5]  
del my_list[2]  # 删除索引为2的元素，即3  
print(my_list)  # 输出: [1, 2, 4, 5]

删除切片

你也可以使用del来删除列表的一个切片，即删除一个范围内的元素。

my_list = [1, 2, 3, 4, 5]  
del my_list[1:3]  # 删除索引从1到2的元素（不包括3），即2和3  
print(my_list)  # 输出: [1, 4, 5]

删除整个对象

del也可以用来删除整个对象，包括列表、字典等。

my_list = [1, 2, 3]  
del my_list  # 删除整个列表  
# 尝试访问my_list将引发NameError  
# print(my_list)  # 这会抛出一个NameError  
  
my_dict = {'a': 1, 'b': 2}  
del my_dict  # 删除整个字典  
# 尝试访问my_dict将引发NameError  
# print(my_dict)  # 这会抛出一个NameError

注意事项

• 使用del删除对象时，如果这是对该对象的最后一个引用，则对象将被垃圾回收。但是，如果还有其他引用指向该对象，那么对象将不会被删除。
• 尝试删除不存在的变量或索引会抛出NameError或IndexError。
• del不能用于删除元组中的元素，因为元组是不可变的。但是，你可以删除整个元组对象。
• 在使用del删除字典中的元素时，你可以通过键来删除。

my_dict = {'a': 1, 'b': 2}  
del my_dict['a']  # 删除键为'a'的元素  
print(my_dict)  # 输出: {'b': 2}

序列相关函数

在Python中，与序列（如列表、元组、字符串等）相关的函数非常丰富，它们提供了对序列进行各种操作的能力。以下是一些常用的与序列相关的函数和方法的概述：

通用函数

• len(s)：返回序列s的长度（元素个数）。
• max(s) 和 min(s)：返回序列s中的最大值和最小值。对于字符串，比较基于ASCII或Unicode码点。
• sum(iterable, start=0)：返回可迭代对象iterable中所有元素的总和，start是可选的，用于累加的初始值。
• sorted(iterable, *, key=None, reverse=False)：返回一个新的列表，包含iterable中所有元素的一个排序副本。key用于指定一个函数，该函数会在每个元素上调用以提取比较键；reverse是一个布尔值，用于指定排序顺序。

列表（List）特有的方法

• append(x)：在列表末尾添加一个新的元素x。
• extend(iterable)：通过添加来自iterable的每个元素来扩展列表。
• insert(i, x)：在指定位置i插入元素x。
• remove(x)：移除列表中第一个值为x的元素。如果找不到这样的元素，则抛出ValueError。
• pop([i])：移除并返回列表中的元素（默认为最后一个元素）。如果指定了索引i，则移除该位置的元素。
• index(x[, start[, end]])：返回列表中第一个值为x的元素的索引。如果没有找到这样的元素，则抛出ValueError。start和end参数用于指定搜索的起始和结束位置。
• count(x)：返回列表中值等于x的元素个数。
• sort(*, key=None, reverse=False)：就地对列表进行排序。key和reverse参数与sorted()函数相同。
• reverse()：就地反转列表中的元素顺序。
• clear()（Python 3.3+）：移除列表中的所有元素，使其变为空列表。

字符串（String）特有的方法

字符串是不可变的，因此它们没有像列表那样的append()、extend()或insert()等方法。但是，它们有许多用于字符串操作的方法，如：

• strip([chars])、lstrip([chars])、rstrip([chars])：分别用于移除字符串开头、结尾或两端的指定字符（默认为空白字符）。
• split(sep=None, maxsplit=-1)：通过指定的分隔符sep将字符串分割成一个列表，maxsplit参数限制分割次数。
• join(iterable)：将序列iterable中的元素以字符串作为分隔符连接成一个新的字符串。
• replace(old, new[, count])：将字符串中的old替换为new，如果指定了count，则替换不超过count次。
• find(sub[, start[, end]])、index(sub[, start[, end]])：查找子字符串sub，find()找不到时返回-1，而index()找不到时抛出ValueError。start和end参数用于指定搜索的起始和结束位置。
• upper()、lower()、capitalize()、title()、swapcase()：分别用于将字符串转换为大写、小写、首字母大写、每个单词首字母大写、大小写反转。

注意事项

• 序列类型（如列表和元组）支持索引和切片操作，但元组是不可变的，因此不支持修改其元素的方法（如append()、extend()等）。
• 字符串也是不可变的，但提供了丰富的字符串操作方法。
• 列表和字符串都有count()和index()方法，但它们的用途略有不同（列表用于查找元素，字符串用于查找子字符串）。
• 列表的sort()方法和内置的sorted()函数都用于排序，但sort()会就地修改列表，而sorted()会返回一个新的列表。

迭代器和可迭代对象

在Python中，迭代器和可迭代对象是两个紧密相关但又有明确区别的概念。理解这两个概念对于编写高效、可维护的Python代码至关重要。

可迭代对象（Iterable）

可迭代对象是指那些实现了__iter__()方法的对象。这意味着你可以使用iter()函数从它们那里获取一个迭代器。几乎所有的Python集合（如列表、元组、字典、集合等）都是可迭代对象。此外，字符串、文件对象等也是可迭代对象。

简而言之，可迭代对象是一个容器，它包含了可以逐个遍历的元素，但是它不提供直接访问这些元素的机制（比如索引），而是通过迭代器来实现遍历。

迭代器（Iterator）

迭代器是一个实现了__iter__()和__next__()方法的对象。迭代器是Python中的一个用于迭代（即按顺序访问元素）的抽象概念。__iter__()方法返回迭代器对象本身，而__next__()方法返回容器中的下一个元素。如果在容器中没有更多元素，则__next__()方法应该抛出一个StopIteration异常来通知迭代的结束。

迭代器提供了一种不暴露其内部表示的方法来遍历容器中的元素。这使得迭代器能够支持多种不同的遍历协议，包括正向迭代和反向迭代。

示例

这里有一个简单的例子来说明可迭代对象和迭代器的区别：

# 列表是可迭代对象  
my_list = [1, 2, 3, 4]  
iter_list = iter(my_list)  # 从可迭代对象获取迭代器  
  
# 使用迭代器遍历元素  
while True:  
    try:  
        print(next(iter_list))  # 调用迭代器的__next__()方法  
    except StopIteration:  
        break  # 如果没有更多元素，则跳出循环  
  
# 自定义迭代器  
class Counter:  
    def __init__(self, low, high):  
        self.current = low  
        self.high = high  
  
    def __iter__(self):  
        # 返回迭代器对象本身  
        return self  
  
    def __next__(self):  
        if self.current > self.high:  
            raise StopIteration  
        else:  
            self.current += 1  
            return self.current - 1  
  
# 使用自定义迭代器  
for number in Counter(3, 8):  
    print(number)

在这个例子中，my_list是一个可迭代对象，我们通过iter()函数从它那里获取了一个迭代器iter_list。然后，我们使用next()函数和while循环遍历了列表中的元素。此外，我们还定义了一个名为Counter的自定义迭代器类，它实现了__iter__()和__next__()方法，并展示了如何在for循环中使用这个自定义迭代器。