Python 学习4-集合、序列

六、集合

集合与字典类似,但是只有键没有值,键为不可变类型,即可以哈希
(1)集合的创建

1. 先创建对象,在向里头添加元素,空集合(Eg:s=set()),同样不可以添加表

basket=set()
basket.add('das')
basket.add(123)
basket.add((231,235,423))
print(basket) #{123, 'das', (231, 235, 423)}

2. 类似字典直接用大括号{},重复元素会自动被过滤

basket={'dasda',('das',321),134}
print(basket) #{('das', 321), 'dasda', 134}

3. 直接使用工厂函数set(value),把列表和元组转换成集合,不可以是数字,想要完整的录入一个字符串,要用[’ ']或者" ",单引号会录入组成的各个字母

basket1=set('dsaasag')
print(basket1) #{'s', 'a', 'd', 'g'}
basket2=set(('dasd',432))
print(basket2) #{432, 'dasd'}
basket3=set(['gsf',64])
print(basket3) #{64, 'gsf'}
basket4=set(1231)
print(basket4) #TypeError: 'int' object is not iterable

从列表中去掉相同元素

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]

集合是无序且唯一的,所以对集合不能创建索引和进行切片操作,也没有键来获取值,但是可以判断一个元素是否在集合中
(2)集合的访问

1. len看数组的大小

basket=set(('fs',321))
print(basket) #{321, 'fs'}
print(len(basket)) #2

2. for遍历集合

basket={4532,'dsfda',('dasg',798)}
for item in basket:
print(item) #dsfda     4532      ('dasg', 798)

3. in & not in看元素是否存在集合中

basket={4532,'dsfda',('dasg',798)}
print('das' in basket) #False
print('das' not in basket) #True
print(4532 in basket) #True
print(4532 not in basket) #False

(3)集合的内置

1. set.add
   set.add()向集合中添加元素

basket={231,'fsdj'}
basket.add((4322,'gdfg'))
print(basket) #{'fsdj', (4322, 'gdfg'), 231}

2. set.update
   set.update()向集合里添加新元素或集合,重复的会忽略

basket=set([1234,546,'uhy'])
print(basket) #{'uhy', 1234, 546}
basket.update("gfdhjk")
print(basket) #{546, 'h', 'f', 'j', 'k', 1234, 'g', 'uhy', 'd'}
basket.update(['gfdhjk'])
print(basket)
 #{546, 'h', 'f', 'j', 'gfdhjk', 'k', 1234, 'g', 'uhy', 'd'}

3. set.remove
   set.remove(item)移除集合中的指定的元素,如果没有这个元素,会有错误

basket={"fsdf",563}
print(basket) #{563, 'fsdf'}
basket.remove(563)
print(basket) #{'fsdf'}
basket.remove('dsfs')
print(basket) #KeyError: 'dsfs'

4. set.discard
   set.discard(value)也是用于移除集合中的指定元素,就算没有这个元素,也不会报错

basket={32131,'gfdj'}
print(basket) #{'gfdj', 32131}
basket.discard(32131)
print(basket) #{'gfdj'}
basket.discard('fhsjk')
print(basket) #{'gfdj'}

5. set.pop
   set.pop()随机移除一个元素

basket={'sdada',43}
print(bakset) #{43, 'sdada'}
basket.pop()
print(basket) #{'sdada'}

6. set.intersection
   basket1.intersection(basket2)返回两个集合的交集
   basket1&bakset2返回两个集合的交集
   set.intersection_update
   basket1.set.intersection_update(basket2) 在basket1集合上移除不一样的,剩下一样的,也就是交集,没有返回值

basket1=set('dsdahtrj')
basket2=set('dfhaooif')
print(basket1) #{'h', 'a', 't', 'j', 'r', 's', 'd'}
print(basket2) #{'h', 'a', 'i', 'f', 'o', 'd'}
a=basket1.intersection(basket2)
print(a) #{'h', 'a', 'd'}
print(basket1&basket2) #{'h', 'a', 'd'}
basket1.intersection_update(basket2)
print(basket1) #{'h', 'a', 'd'}

7. set.union
   basket1.union(basket2)返回2个集合的并集
   basket1 | basket2返回2个集合的并集

basket1=set('dsdahtrj')
basket2=set('dfhaooif')
print(basket1) #{'h', 'a', 't', 'j', 'r', 's', 'd'}
print(basket2) #{'h', 'a', 'i', 'f', 'o', 'd'}
print(basket1.union(basket2))
 #{'t', 'j', 'h', 'd', 's', 'f', 'i', 'o', 'r', 'a'}
print(basket1 | basket2)
 #{'t', 'j', 'h', 'd', 's', 'f', 'i', 'o', 'r', 'a'}

8. set.difference
   basket1.difference(basket2)返回2个集合的差集
   basket1 - basket2返回2个集合的差集
   **basket1.difference_update(basket2)**在basket1集合中移除一样的,没有返回值

basket1=set('dsdahtrj')
basket2=set('dfhaooif')
print(basket1) #{'t', 'j', 'h', 'd', 's', 'r', 'a'}
print(basket2) #{'h', 'd', 'f', 'i', 'o', 'a'}
print(basket1.difference(basket2)) #{'t', 'j', 's', 'r'}
print(basket1 - basket2) #{'t', 'j', 's', 'r'}
basket1.difference_update(basket2)
print(basket1) #{'t', 'j', 's', 'r'}

9. set.symmetric_difference
   basket1.symmetric_difference(basket2)返回2个集合的异或(并集减去交集)
   basket1^basket2返回2个集合的异或
   **basket1.symmetric_difference_update(basket2)**在basket1集合中显示异或

basket1=set('dsdahtrj')
basket2=set('dfhaooif')
print(basket1) #{'t', 'j', 'h', 'd', 's', 'r', 'a'}
print(basket2) #{'h', 'd', 'f', 'i', 'o', 'a'}
print(basket1.symmetric_difference(basket2))
 #{'t', 'i', 'j', 'o', 'r', 's', 'f'}
print(basket1^basket2) #{'t', 'i', 'j', 'o', 'r', 's', 'f'}
basket1.symmetric_difference_update(basket2)
print(basket1) #{'t', 'j', 's', 'f', 'i', 'o', 'r'}

10. set.issubset
    basket1.issubset(basket2)看basket1是否被basket2包含,是就返回True,不是就返回False
    basket1<=basket2和 set.issubset一样

basket1={'dsada',58967}
basket2={'dsada'}
print(basket1.issubset(basket2)) #False
print(basket2.issubset(basket1)) #True
print(basket1<=basket2) #False

11. set.issuperset
    basket1.issuperset(basket2)看basket1是不是包含basket2,是就返回True,不是就返回False
    basket1>=basket2和set.issuperset一样

basket1={'dsada',58967}
basket2={'dsada'}
print(basket1.issuperset(basket2)) #True
print(basket2.issuperset(basket1)) #False
print(basket1>=basket2) #True

12. set.isdisjoint(set)
    basket1.isdisjoint(basket2)判断是不是不相交,是就返回True,不是就返回False

basket1=set('hfdgjkdgjkh')
basket2=set('lkjgsdf')
basket3=set('dgj')
print(basket1) #{'d', 'g', 'j', 'k', 'h', 'f'}
print(basket2) #{'d', 'g', 'k', 'j', 'f', 's', 'l'}
print(basket2) #{'d', 'g', 'k', 'j', 'f', 's', 'l'}
print(basket1.isdisjoint(basket2)) #False

(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)不可变集合
frozenset
frozenset返回一个冻结的集合,不可以被删除和添加任何元素

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'})
print(b) #AttributeError: 'frozenset' object has no attribute 'add'

六、序列

序列包括字符串、列表、元组、字典、集合,他们支持一些通用的操作、字典和集合不支持索引、切片、相加、相乘

1. 针对序列的内置函数
   可迭代对象:比如:list,字符串,dict,元组,生成器(生成特殊值的函数)等
   **list()**把可迭代对象转换成列表
   **tuple()**把可迭代对象转换成元组
   **str()**把对象转换成字符串

a=[132,'fgd']
print(a,type(a)) #[132, 'fgd'] <class 'list'>
a1=tuple(a)
print(a1,type(a1)) #(132, 'fgd') <class 'tuple'>
a2=str(a)
print(a2,type(a2)) #[132, 'fgd'] <class 'str'>

b=(123,'gsfhj')
print(b,type(b)) #(123, 'gsfhj') <class 'tuple'>
b1=list(b)
print(b1,type(b1)) #[123, 'gsfhj'] <class 'list'>
b2=str(b)
print(b2,type(b2)) #(123, 'gsfhj') <class 'str'>

c='dsaad'
print(c,type(c)) #dsaad <class 'str'>
d={'gfs':'fdsh',43:7}
print(d,type(d)) #{'gfs': 'fdsh', 43: 7} <class 'dict'>
e={'skhjgf',657}
print(e,type(e)) #{'skhjgf', 657} <class 'set'>

2. len返回对象的长度或元素个数

a=list()
print(len(a))  # 0

b=('I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p')
print(len(b))  # 16

c='I Love LsgoGroup'
print(len(c))  # 16

3. max返回序列或参数集合中的最大值

print(max(1, 2, 3, 4, 5))  # 5
print(max([-8, 99, 3, 7, 83]))  # 99
print(max('IloveLsgoGroup'))  # v

4. min返回序列或参数集合中的最小值

print(min(1, 2, 3, 4, 5))  # 1
print(min([-8, 99, 3, 7, 83]))  # -8
print(min('IloveLsgoGroup'))  # G

5. sum返回序列与可选参数的总和

print(sum([1, 3, 5, 7, 9]))  # 25
print(sum([1, 3, 5, 7, 9], 10))  # 35
print(sum((1, 3, 5, 7, 9)))  # 25
print(sum((1, 3, 5, 7, 9), 20))  # 45
print(sum('fsfs',1)) 
#TypeError: unsupported operand type(s) for +: 'int' and 'str'

6. sorted排序
   sorted(’ ‘,key,reverse)’ ‘是可迭代对象,key是主要用来比较的对象
   reverse排序规则True降序False升序(默认)
   lambda是一个模拟函数 后边的是函数本题中就是返回b["name’]

a=(5641,1984,56497,56456)
print(sorted(a)) #[1984, 5641, 56456, 56497]
print(sorted(a,reverse=True)) #[56497, 56456, 5641, 1984]
b=({"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"})
print(sorted(b,key=lambda b:b["name"],reverse=True)) 
#[{'age': 10, 'name': 'c'}, {'age': 25, 'name': 'b'}, {'age': 20, 'name': 'a'}]

7. reversed反转,可以反转元组,字符串,列表,range

a={4234,'sgf'}
print(a,type(a)) #{4234, 'sgf'} <class 'set'>
a1=reversed(a)
print(a1,type(a1)) #TypeError: 'set' object is not reversible

b=(321,57,987)
print(b,type(b)) #(321, 57, 987) <class 'tuple'>
b1=reversed(b)
print(b1,type(b1)) #<reversed object at 0x7f95a9758b38> <class 'reversed'>

8. enumrate
   enumrate(数据对象,编号)

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')]

9. zip
   zip(a,b)将a,b打包成一个元组,返回这些元组组成的对象,这么做好处是可以节约空间,可以用list()来输出列表,一一对应的

a=(312,'fgjf')
b=['fjfgh',57]
c=zip(a,b)
print(c) #
print(list(c)) #[(312, 'fjfgh'), ('fgjf', 57)]
print(tuple(c)) #()
d=(543,'hfgj',675)
e=zip(a,d)
print(list(e)) #[(312, 543), ('fgjf', 'hfgj')]