python 训练营打卡第六天
集合 序列
- python 训练营打卡第六天
- 集合
-
- 1. 集合的创建
- 2. 访问集合中的值
- 3. 集合的内置方法
- 4. 集合的转换
- 5. 不可变集合
- 序列
- 1. 针对序列的内置函数
集合
Python 中
set
与
dict
类似,也是一组
key
的集合,但不存储
value
。由于
key
不能重复,所以,在
set
中,没有重复的
key
。
注意,
key
为不可变类型,即可哈希的值。
1. 集合的创建
- 先创建对象再加入元素。
- 在创建空集合的时候只能使用
,因为s = set()
创建的是空字典。s = {}
basket = set()
basket.add('apple')
basket.add('banana')
print(basket) # {'banana', 'apple'}
直接把一堆元素用花括号括起来
{元素1, 元素2, ..., 元素n}
。
- 重复元素在
中会被自动被过滤。set
- 使用
工厂函数,把列表或元组转换成集合。set(value)
a = set('abracadabra')
print(a)
# {'r', 'b', 'd', 'c', 'a'}
b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))
print(b)
# {'Taobao', 'Lsgogroup', 'Google'}
c = set(["Google", "Lsgogroup", "Taobao", "Google"])
print(c)
# {'Taobao', 'Lsgogroup', 'Google'}
解释set
lst = [0, 1, 2, 3, 4, 5, 5, 3, 1]
temp = []
for item in lst:
if item not in temp:
temp.append(item)
print(temp) # [0, 1, 2, 3, 4, 5]
a = set(lst)
print(list(a)) # [0, 1, 2, 3, 4, 5]
从结果发现集合的两个特点:无序 (unordered) 和唯一 (unique)。
由于 `set` 存储的是无序集合,所以我们不可以为集合创建索引或执行切片(slice)操作,也没有键(keys)可用来获取集合中元素的值,但是可以判断一个元素是否在集合中。
2. 访问集合中的值
- 可以使用
內建函数得到集合的大小。len()
s = set(['Google', 'Baidu', 'Taobao'])
print(len(s)) # 3
- 可以使用
把集合中的数据一个个读取出来。for
s = set(['Google', 'Baidu', 'Taobao'])
for item in s:
print(item)
# Baidu
# Google
# Taobao
- 可以通过
或in
判断一个元素是否在集合中已经存在not in
-
3. 集合的内置方法
-
用于给集合添加元素,如果添加的元素在集合中已存在,则不执行任何操作。set.add(elmnt)
-
用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略。set.update(set)
x = {"apple", "banana", "cherry"}
y = {"google", "baidu", "apple"}
x.update(y)
print(x)
# {'cherry', 'banana', 'apple', 'google', 'baidu'}
y.update(["lsgo", "dreamtech"])
print(y)
# {'lsgo', 'baidu', 'dreamtech', 'apple', 'google'}
-
用于移除集合中的指定元素。如果元素不存在,则会发生错误。set.remove(item)
-
-
用于移除指定的集合元素。set.discard(value)
方法在移除一个不存在的元素时会发生错误,而remove()
方法不会。discard()
-
-
用于随机移除一个元素。set.pop()
- 由于 set 是无序和无重复元素的集合,所以两个或多个 set 可以做数学意义上的集合操作。
-
返回两个集合的交集。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)
-
判断集合是不是被其他集合包含,如果是则返回 True,否则返回 False。set.issubset(set)
-
判断集合是不是被其他集合包含,如果是则返回 True,否则返回 False。set1 <= set2
-
用于判断集合是不是包含其他集合,如果是则返回 True,否则返回 False。set.issuperset(set)
-
判断集合是不是包含其他集合,如果是则返回 True,否则返回 False。set1 >= set2
-
用于判断两个集合是不是不相交,如果是返回 True,否则返回 False。set.isdisjoint(set)
-
4. 集合的转换
【例子】
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'>
5. 不可变集合
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'})
序列
在 Python 中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持一些通用的操作,但比较特殊的是,集合和字典不支持索引、切片、相加和相乘操作。
1. 针对序列的内置函数
-
把一个可迭代对象转换为列表。list(sub)
【例子】
a = list()
print(a) # []
b = 'I Love LsgoGroup'
b = list(b)
print(b)
# ['I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p']
c = (1, 1, 2, 3, 5, 8)
c = list(c)
print(c) # [1, 1, 2, 3, 5, 8]
-
把一个可迭代对象转换为元组。tuple(sub)
-
-
把obj对象转换为字符串str(obj)
-
-
返回对象(字符、列表、元组等)长度或元素个数。len(s)
-
– 对象。s
-
-
返回序列或者参数集合中的最大值max(sub)
-
返回序列或参数集合中的最小值min(sub)
-
-
返回序列sum(iterable[, start=0])
与可选参数iterable
的总和。start
-
-
-
对所有可迭代的对象进行排序操作。sorted(iterable, key=None, reverse=False)
-
– 可迭代对象。iterable
-
– 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。key
-
– 排序规则,reverse
降序 ,reverse = True
升序(默认)。reverse = False
-
返回重新排序的列表。
sorted经常用的到
-
-
x = [-8, 99, 3, 7, 83]
print(sorted(x)) # [-8, 3, 7, 83, 99]
print(sorted(x, reverse=True)) # [99, 83, 7, 3, -8]
t = ({"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"})
x = sorted(t, key=lambda a: a["age"])
print(x)
# [{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]
-
函数返回一个反转的迭代器。reversed(seq)
-
– 要转换的序列,可以是 tuple, string, list 或 range。seq
-
【例子】
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']
t = ('l', 's', 'g', 'o', 'g', 'r', 'o', 'u', 'p')
print(list(reversed(t)))
# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']
r = range(5, 9)
print(list(reversed(r)))
# [8, 7, 6, 5]
x = [-8, 99, 3, 7, 83]
print(list(reversed(x)))
# [83, 7, 3, 99, -8]
-
enumerate(sequence, [start=0])
【例子】用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
a = list(enumerate(seasons))
print(a)
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
b = list(enumerate(seasons, 1))
print(b)
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
for i, element in a:
print('{0},{1}'.format(i, element))
# 0,Spring
# 1,Summer
# 2,Fall
# 3,Winter
-
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]
感觉这个有点超前了。。。