学习python Task 5 集合、序列 笔记

1. 集合

集合 set 中的元素为不可变类型（即可哈希），且元素不重复，无序。无法为集合创建索引和切片。集合的形式和字典类似，都是大括号形式，但集合的内部元素不是键值对。

集合的创建

（1）创建空集合只能使用s=set()，区别于字典的创建dic={}。
先创建空集合，s=set()，然后通过add函数添加元素，s.add('a')。
（2）直接初始化创建s={元素1, 元素2, ..., 元素n}。其中的重复元素会被自动过滤。所以，可以将列表直接用法（3）转变成集合，再变回列表，即可去掉列表中的重复元素。
（3）使用set(value)工厂函数，把列表或元组转换成集合。
示例：

a = set('abracadabra')
print(a)  
# {'r', 'b', 'd', 'c', 'a'}

b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))
print(b)  
# {'Taobao', 'Lsgogroup', 'Google'}

访问集合中的值

s = set(['Google', 'Baidu', 'Taobao'])
for item in s:
    print(item)
# Baidu
# Google
# Taobao

不能用索引！错误示范：

s={'a','b','c','d'}
for i in range(len(s)):
    print(s[i])

集合的内置方法

（1）set.add(elmnt)用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。
（2）set1.update(set2)用于修改当前集合（把set2更新到set1中），可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。
（3）set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误。
（4）set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
（5）set.pop() 用于随机移除一个元素。返回值为该元素。
（6）数学意义上的集合操作
set.intersection(set1, set2) 返回两个集合的交集。不改变原来的集合。
set1 & set2 返回两个集合的交集。不改变原来的集合。
set.intersection_update(set1, set2) 交集，在原始的集合上移除不重叠的元素。改变原来的集合。

a = set('abracadabra')
b = set('alacazam')
print(a)  # {'r', 'a', 'c', 'b', 'd'}
print(b)  # {'c', 'a', 'l', 'm', 'z'}

c = a.intersection(b)
print(c)  # {'a', 'c'}
print(a & b)  # {'c', 'a'}
print(a)  # {'a', 'r', 'c', 'b', 'd'}

a.intersection_update(b)
print(a)  # {'a', 'c'}

set.union(set1, set2) 返回两个集合的并集。
set1 | set2 返回两个集合的并集。

set.difference(set) 返回集合的差集。
set1 - set2 返回集合的差集。
set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值。

set.symmetric_difference(set)返回集合的异或。
set1 ^ set2 返回集合的异或。
set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

set1.issubset(set2)判断集合set1是不是被其他集合set2包含，如果是则返回 True，否则返回 False。
set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。

set.issuperset(set)用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。

set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

集合的转换

se = set(range(4))
li = list(se)
tu = tuple(se)
print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>

不可变集合

Python 提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫 frozenset 。需要注意的是 frozenset 仍然可以进行集合操作，只是不能用带有update的方法。
frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

a = frozenset(range(10))  # 生成一个新的不可变集合
print(a)  
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
b = frozenset('lsgogroup')
print(b)  
# frozenset({'g', 's', 'p', 'r', 'u', 'o', 'l'})

练习

1. 怎么表示只包含⼀个数字1的元组。

s = (1,)

2. 创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。

s = set()
s.add('x')
s.add('y')
s.add('z')

3. 列表[‘A’, ‘B’, ‘A’, ‘B’]去重。

a = ['A', 'B', 'A', 'B']
a = list(set(a))

4. 求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素（差集指的是两个集合交集外的部分）。

a = {6, 7, 8}
b = {7, 8, 9}
a.symmetric_difference_update(b)

5. 求{‘A’, ‘B’, ‘C’}中元素在 {‘B’, ‘C’, ‘D’}中出现的次数。

a = {'A', 'B', 'C'}
b = {'B', 'C', 'D'}
c = a & b
print(c)
print(len(c))

2. 序列

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

针对序列的内置函数

1. 转换

list(sub)
tuple(sub)
str(obj)

2. len(obj)返回对象的长度（元素个数）。
3. max(sub)返回序列或参数集合中的最大值；min(sub)返回最小值。
4. sum(iterable[, s=0]) 返回序列 iterable 与可选参数 s 的总和。
5. 排序：sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。key 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse 排序规则，True 降序，False 升序（默认）。返回重新排序的列表。
6. reversed(seq) 函数返回一个反转的迭代器。seq 为要转换的序列，可以是 tuple, string, list 或 range。

s = 'lsgogroup'
x = reversed(s)
print(type(x))  # <class 'reversed'>
print(x)  # <reversed object at 0x000002507E8EC2C8>
print(list(x))
# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']

7. enumerate(sequence, [start=0]) 用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
a = list(enumerate(seasons))
print(a)  
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
for i, element in a:
    print('{0},{1}'.format(i, element))
# 0,Spring
# 1,Summer
# 2,Fall
# 3,Winter

8. zip(iter1 [,iter2 [...]]) 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
   我们可以使用 list() 转换来输出列表。
   如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]

zipped = zip(a, b)
print(zipped)  # <zip object at 0x000000C5D89EDD88>
print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
zipped = zip(a, c)
print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]

a1, a2 = zip(*zip(a, b))
print(list(a1))  # [1, 2, 3]
print(list(a2))  # [4, 5, 6]

练习

1. 怎么找出序列中的最大、小值？
   max和min函数
2. sort() 和 sorted() 区别？
   sort用于列表，sorted用于所有可迭代对象的排序。
3. 怎么快速求 1 到 100 所有整数相加之和？

sum(range(1,101))

4. 求列表 [2,3,4,5] 中每个元素的立方根。

import math
lst = [2, 3, 4, 5, 8]
l = []
for i in range(len(lst)):
    l.append(math.pow(lst[i], 1.0/3))
print(l)

5. 将[‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式。

a = ['x', 'y', 'z']
b = [1, 2, 3]
c = list(zip(a, b))
print(c)