高级数据类型之Python篇

lsekfe

集合 (Set)
　　集合是一种无序、可变、且元素唯一的数据结构。在Python 中，可以通过 set() 函数或使用大括号 {} 来创建一个集合。
　　创建集合
　　# 创建一个空集合
　　empty_set = set()
　　print(empty_set)
　　# 创建带有初始元素的集合
　　numbers = {1, 2, 3, 4, 5}
　　print(numbers)


　　输出：
　　set()
　　{1, 2, 3, 4, 5}


　　注意，如果使用大括号创建一个空集合，会得到一个空字典而不是空集合。所以，创建空集合时应该使用 set() 函数。
　　集合的基本操作
　　添加元素
　　可以使用 add() 方法向集合中添加元素，如果添加的元素已经存在于集合中，则不会有任何影响。
　　fruits = {'apple', 'banana', 'orange'}
　　fruits.add('grape')
　　fruits.add('apple')  # 不会有任何影响，因为'apple'已经存在于集合中
　　print(fruits)


　　输出：
　　{'banana', 'grape', 'apple', 'orange'}

　　删除元素
　　可以使用 remove() 或 discard() 方法从集合中删除指定元素，如果元素不存在，则 remove() 方法会抛出 KeyError 异常，而 discard() 方法不会有任何影响。
　　fruits = {'apple', 'banana', 'orange'}
　　fruits.remove('banana')
　　print(fruits)
　　fruits.discard('watermelon')  # 不会有任何影响，因为'watermelon'不存在于集合中
　　print(fruits)


　　输出：
　　{'apple', 'orange'}
　　{'apple', 'orange'}


　　集合运算
　　可以对集合执行交集、并集、差集、对称差等运算。
　　A = {1, 2, 3, 4, 5}
　　B = {4, 5, 6, 7, 8}
　　print(A & B)  # 交集
　　print(A | B)  # 并集
　　print(A - B)  # 差集
　　print(A ^ B)  # 对称差


　　输出：
　　{4, 5}
　　{1, 2, 3, 4, 5, 6, 7, 8}
　　{1, 2, 3}
　　{1, 2, 3, 6, 7, 8}


　　代码演示
　　# 创建一个空集合
　　empty_set = set()
　　print(empty_set)
　　# 创建带有初始元素的集合
　　numbers = {1, 2, 3, 4, 5}
　　print(numbers)
　　# 添加元素
　　fruits = {'apple', 'banana', 'orange'}
　　fruits.add('grape')
　　fruits.add('apple')  # 不会有任何影响，因为'apple'已经存在于集合中
　　print(fruits)
　　# 删除元素
　　fruits.remove('banana')
　　print(fruits)
　　fruits.discard('watermelon')  # 不会有任何影响，因为'watermelon'不存在于集合中
　　print(fruits)
　　# 集合运算
　　A = {1, 2, 3, 4, 5}
　　B = {4, 5, 6, 7, 8}
　　print(A & B)  # 交集
　　print(A | B)  # 并集
　　print(A - B)  # 差集
　　print(A ^ B)  # 对称差


　　输出：
　　set()
　　{1, 2, 3, 4, 5}
　　{'orange', 'banana', 'grape', 'apple'}
　　{'orange', 'grape', 'apple'}
　　{'orange', 'grape', 'apple'}
　　{4, 5}
　　{1, 2, 3, 4, 5, 6, 7, 8}
　　{1, 2, 3}
　　{1, 2, 3, 6, 7, 8}


　　命名元组 (NamedTuple)
　　命名元组是一种具名元素的元组。与普通元组不同，命名元组的每个元素都有一个可读性更高的名称。在 Python 中，可以通过 collections 模块中的 namedtuple() 函数来创建一个命名元组。
　　创建命名元组
　　创建命名元组时需要指定元素的名称和顺序，可以使用逗号分隔的字符串或者是元素名称组成的列表来定义。
　　from collections import namedtuple
　　# 用逗号分隔的字符串定义元素
　　Person = namedtuple('Person', 'name age gender')
　　p1 = Person('Bob', 25, 'male')
　　print(p1)
　　# 使用元素名称组成的列表定义元素
　　Point = namedtuple('Point', ['x', 'y'])
　　p2 = Point(3.14, 2.71)
　　print(p2)


　　输出：
　　Person(name='Bob', age=25, gender='male')
　　Point(x=3.14, y=2.71)


　　访问命名元组
　　可以使用点号运算符来访问命名元组中的元素。
　　print(p1.name)
　　print(p2.y)


　　输出：
　　Bob
　　2.71


　　修改命名元组
　　命名元组是不可变的，因此不能直接修改其元素。但可以使用 _replace() 方法创建一个新的命名元组，该方法会返回一个新的命名元组，其中指定的元素会被替换为新的值。注意，_replace() 方法并不会改变原来的命名元组，而是返回一个新的命名元组。
　　p3 = p2._replace(y=42)
　　print(p2)
　　print(p3)


　　输出：
　　Point(x=3.14, y=2.71)
　　Point(x=3.14, y=42)


　　迭代器和生成器
　　迭代器和生成器是 Python 中非常重要的概念，它们可以帮助我们有效地处理大量数据，避免内存溢出的问题。
　　迭代器 (Iterator)
　　迭代器是一种可以逐个访问集合元素的对象，而不必将集合完全加载到内存中。迭代器对象从第一个元素开始访问，直到所有元素都被访问完为止。在 Python 中，可以使用 iter() 和 next() 函数来创建和访问迭代器。
　　numbers = [1, 2, 3, 4, 5]
　　it = iter(numbers)
　　print(next(it))
　　print(next(it))
　　print(next(it))
　　print(next(it))
　　print(next(it))


　　输出：
　　1
　　2
　　3
　　4
　　5


　　生成器 (Generator)
　　生成器是一种特殊的迭代器，可以使用函数来创建。与普通函数不同，生成器函数返回的是一个迭代器对象，可以使用 yield 关键字来逐个返回值，而不是一次性返回所有值。
　　def square_numbers(n):
　　    for i in range(n):
　　        yield i ** 2
　　# 创建生成器对象
　　my_generator = square_numbers(5)
　　# 访问生成器中的元素
　　print(next(my_generator))
　　print(next(my_generator))
　　print(next(my_generator))
　　print(next(my_generator))
　　print(next(my_generator))


　　输出：
　　0
　　1
　　4
　　9
　　16


　　生成器的一个重要特点是可以节省内存，因为它不需要将所有元素保存在内存中，而是逐个生成元素。此外，生成器还可以实现无限序列的生成，比如生成所有的斐波那契数列元素。以下是一个生成斐波那契数列的生成器函数示例：
　　def fibonacci():
　　    a, b = 0, 1
　　    while True:
　　        yield a
　　        a, b = b, a + b
　　# 创建生成器对象
　　my_generator = fibonacci()
　　# 访问生成器中的元素
　　print(next(my_generator))
　　print(next(my_generator))
　　print(next(my_generator))
　　print(next(my_generator))
　　print(next(my_generator))
　　print(next(my_generator))


　　输出：
　　0
　　1
　　1
　　2
　　3
　　5


　　除了使用 next() 函数来访问生成器中的元素之外，我们还可以使用 for 循环来遍历生成器中的所有元素，因为生成器也是一种可迭代对象。
　　# 创建生成器对象
　　my_generator = square_numbers(5)
　　# 遍历生成器中的元素
　　for num in my_generator:
　　    print(num)


　　输出：
　　0
　　1
　　4
　　9
　　16


　　另外一个有用的函数是 send()，它可以在调用生成器函数时向生成器中传递一个值，并从当前位置继续执行生成器函数。具体来说，send() 函数会将传递的值作为 yield 表达式的返回值，并将生成器函数的执行从 yield 表达式后的下一条语句开始执行。以下是一个示例：
　　def square_numbers():
　　    num = 0
　　    while True:
　　        # 从外部接收一个值
　　        x = yield num ** 2
　　        if x is not None:
　　            num = x
　　        else:
　　            num += 1
　　# 创建生成器对象
　　my_generator = square_numbers()
　　# 访问生成器中的元素，并向生成器中传递一个值
　　print(next(my_generator))
　　print(next(my_generator))
　　print(my_generator.send(5))
　　print(next(my_generator))


　　输出：
　　0
　　1
　　25
　　36


　　在上面的示例中，我们定义了一个生成器函数 square_numbers()，它会不断地生成平方数。在函数中，我们使用 yield 表达式来逐个返回平方数，并将 num 的初始值设置为 0。当从外部通过 send() 函数向生成器中传递一个值时，我们可以在函数中将 num 的值修改为传递的值，并从 yield 表达式后的下一条语句开始执行。
　　以上就是迭代器和生成器的基本介绍，它们是 Python 中非常重要的概念，可以帮助我们高效地处理大量数据。