集合
Python中set
与dict
类似,也是一组key
的集合,但不存储value
。由于key
不能重复,所以,在set
中,没有重复的key
注意,key
为不可变类型,即可哈希的值
num = { }
print ( type ( num) )
num = { 1 , 2 , 3 , 4 }
print ( type ( num) )
1.集合的创建
先创建对象再加入元素 在创建空集合的时候只能使用s = set()
,因为s = {}
创建的是空字典
basket = set ( )
basket. add( 'apple' )
basket. add( 'banana' )
print ( basket)
直接把一堆元素用花括号括起来{元素1, 元素2, …, 元素n} 重复元素在set
中会被自动被过滤
basket = { 'apple' , 'orange' , 'apple' , 'pear' , 'orange' , 'banana' }
print ( basket)
使用set(value)
工厂函数,把列表或元组转换成集合
a = set ( 'abracadabra' )
print ( a)
b = set ( ( "Google" , "Lsgogroup" , "Taobao" , "Taobao" ) )
print ( b)
c = set ( [ "Google" , "Lsgogroup" , "Taobao" , "Google" ] )
print ( c)
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)
a = set ( lst)
print ( list ( a) )
从结果发现集合的两个特点:无序 unordered
和唯一 unique
由于set
存储的是无序集合,所以我们不可以为集合创建索引或执行切片slice
操作,也没有键keys
可用来获取集合中元素的值,但是可以判断一个元素是否在集合中
2.访问集合中的值
s = set ( [ 'Google' , 'Baidu' , 'Taobao' ] )
print ( len ( s) )
s = set ( [ 'Google' , 'Baidu' , 'Taobao' ] )
for item in s:
print ( item)
可以通过in
或not in
判断一个元素是否在集合中已经存在
s = set ( [ 'Google' , 'Baidu' , 'Taobao' ] )
print ( 'Taobao' in s)
print ( 'Facebook' not in s)
3.集合的内置方法
set.add(elmnt)
用于给集合添加元素,如果添加的元素在集合中已存在,则不执行任何操作
fruits = { "apple" , "banana" , "cherry" }
fruits. add( "orange" )
print ( fruits)
fruits. add( "apple" )
print ( fruits)
set.update(set)
用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略
x = { "apple" , "banana" , "cherry" }
y = { "google" , "baidu" , "apple" }
x. update( y)
print ( x)
y. update( [ "lsgo" , "dreamtech" ] )
print ( y)
set.remove(item)
用于移除集合中的指定元素。如果元素不存在,则会发生错误
fruits = { "apple" , "banana" , "cherry" }
fruits. remove( "banana" )
print ( fruits)
set.discard(value)
用于移除指定的集合元素。remove()
方法在移除一个不存在的元素时会发生错误,而discard()
方法不会
fruits = { "apple" , "banana" , "cherry" }
fruits. discard( "banana" )
print ( fruits)
fruits = { "apple" , "banana" , "cherry" }
x = fruits. pop( )
print ( fruits)
print ( x)
由于set
是无序和无重复元素的集合,所以两个或多个set
可以做数学意义上的集合操作 set.intersection(set1, set2)
返回两个集合的交集set1 & set2
返回两个集合的交集set.intersection_update(set1, set2)
交集,在原始的集合上移除不重叠的元素
a = set ( 'abracadabra' )
b = set ( 'alacazam' )
print ( a)
print ( b)
c = a. intersection( b)
print ( c)
print ( a & b)
print ( a)
a. intersection_update( b)
print ( a)
set.union(set1, set2)
返回两个集合的并集set1 | set2
返回两个集合的并集
a = set ( 'abracadabra' )
b = set ( 'alacazam' )
print ( a)
print ( b)
print ( a | b)
c = a. union( b)
print ( c)
set.difference(set)
返回集合的差集set1 - set2
返回集合的差集set.difference_update(set)
集合的差集,直接在原来的集合中移除元素,没有返回值
a = set ( 'abracadabra' )
b = set ( 'alacazam' )
print ( a)
print ( b)
c = a. difference( b)
print ( c)
print ( a - b)
print ( a)
a. difference_update( b)
print ( a)
set.symmetric_difference(set)
返回集合的异或set1 ^ set2
返回集合的异或set.symmetric_difference_update(set)
移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中
a = set ( 'abracadabra' )
b = set ( 'alacazam' )
print ( a)
print ( b)
c = a. symmetric_difference( b)
print ( c)
print ( a ^ b)
print ( a)
a. symmetric_difference_update( b)
print ( a)
set.issubset(set)
判断集合是不是被其他集合包含,如果是则返回True
,否则返回False
set1 <= set2
判断集合是不是被其他集合包含,如果是则返回True
,否则返回False
x = { "a" , "b" , "c" }
y = { "f" , "e" , "d" , "c" , "b" , "a" }
z = x. issubset( y)
print ( z)
print ( x <= y)
x = { "a" , "b" , "c" }
y = { "f" , "e" , "d" , "c" , "b" }
z = x. issubset( y)
print ( z)
print ( x <= y)
set.issuperset(set)
用于判断集合是不是包含其他集合,如果是则返回True
,否则返回False
set1 >= set2
判断集合是不是包含其他集合,如果是则返回True
,否则返回False
x = { "f" , "e" , "d" , "c" , "b" , "a" }
y = { "a" , "b" , "c" }
z = x. issuperset( y)
print ( z)
print ( x >= y)
x = { "f" , "e" , "d" , "c" , "b" }
y = { "a" , "b" , "c" }
z = x. issuperset( y)
print ( z)
print ( x >= y)
set.isdisjoint(set)
用于判断两个集合是不是不相交,如果是返回True
,否则返回False
x = { "f" , "e" , "d" , "c" , "b" }
y = { "a" , "b" , "c" }
z = x. isdisjoint( y)
print ( z)
x = { "f" , "e" , "d" , "m" , "g" }
y = { "a" , "b" , "c" }
z = x. isdisjoint( y)
print ( z)
4.集合的转换
se = set ( range ( 4 ) )
li = list ( se)
tu = tuple ( se)
print ( se, type ( se) )
print ( li, type ( li) )
print ( tu, type ( tu) )
5.不可变集合
Python提供了不能改变元素的集合的实现版本,即不能增加或删除元素,类型名叫frozenset
。 需要注意的是frozenset
仍然可以进行集合操作,只是不能用带有update
的方法 frozenset([iterable])
返回一个冻结的集合,冻结后集合不能再添加或删除任何元素
a = frozenset ( range ( 10 ) )
print ( a)
b = frozenset ( 'lsgogroup' )
print ( b)
序列
在Python中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持一些通用的操作,但比较特殊的是,集合和字典不支持索引、切片、相加和相乘操作
1.针对序列的内置函数
a = list ( )
print ( a)
b = 'I Love LsgoGroup'
b = list ( b)
print ( b)
c = ( 1 , 1 , 2 , 3 , 5 , 8 )
c = list ( c)
print ( c)
a = tuple ( )
print ( a)
b = 'I Love LsgoGroup'
b = tuple ( b)
print ( b)
c = [ 1 , 1 , 2 , 3 , 5 , 8 ]
c = tuple ( c)
print ( c)
a = 123
a = str ( a)
print ( a)
len(s)
返回对象(字符、列表、元组等)长度或元素个数,s -- 对象
a = list ( )
print ( len ( a) )
b = ( 'I' , ' ' , 'L' , 'o' , 'v' , 'e' , ' ' , 'L' , 's' , 'g' , 'o' , 'G' , 'r' , 'o' , 'u' , 'p' )
print ( len ( b) )
c = 'I Love LsgoGroup'
print ( len ( c) )
print ( max ( 1 , 2 , 3 , 4 , 5 ) )
print ( max ( [ - 8 , 99 , 3 , 7 , 83 ] ) )
print ( max ( 'IloveLsgoGroup' ) )
print ( min ( 1 , 2 , 3 , 4 , 5 ) )
print ( min ( [ - 8 , 99 , 3 , 7 , 83 ] ) )
print ( min ( 'IloveLsgoGroup' ) )
sum(iterable[, start=0])
返回序列iterable
与可选参数start
的总和
print ( sum ( [ 1 , 3 , 5 , 7 , 9 ] ) )
print ( sum ( [ 1 , 3 , 5 , 7 , 9 ] , 10 ) )
print ( sum ( ( 1 , 3 , 5 , 7 , 9 ) ) )
print ( sum ( ( 1 , 3 , 5 , 7 , 9 ) , 20 ) )
sorted(iterable, key=None, reverse=False)
对所有可迭代的对象进行排序操作 – iterable
– 可迭代对象。 – key
– 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。 – reverse
– 排序规则,reverse = True
降序 , reverse = False
升序(默认)。 – 返回重新排序的列表
x = [ - 8 , 99 , 3 , 7 , 83 ]
print ( sorted ( x) )
print ( sorted ( x, reverse= True ) )
t = ( { "age" : 20 , "name" : "a" } , { "age" : 25 , "name" : "b" } , { "age" : 10 , "name" : "c" } )
x = sorted ( t, key= lambda a: a[ "age" ] )
print ( x)
reversed(seq)
函数返回一个反转的迭代器 – seq
– 要转换的序列,可以是tuple
, string
, list
或 range
s = 'lsgogroup'
x = reversed ( s)
print ( type ( x) )
print ( x)
print ( list ( x) )
t = ( 'l' , 's' , 'g' , 'o' , 'g' , 'r' , 'o' , 'u' , 'p' )
print ( list ( reversed ( t) ) )
r = range ( 5 , 9 )
print ( list ( reversed ( r) ) )
x = [ - 8 , 99 , 3 , 7 , 83 ]
print ( list ( reversed ( x) ) )
enumerate(sequence, [start=0])
用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在for
循环当中
seasons = [ 'Spring' , 'Summer' , 'Fall' , 'Winter' ]
a = list ( enumerate ( seasons) )
print ( a)
b = list ( enumerate ( seasons, 1 ) )
print ( b)
for i, element in a:
print ( '{0},{1}' . format ( i, element) )
zip(iter1 [,iter2 [...]])
– 用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。 – 我们可以使用list()
转换来输出列表。 – 如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表
a = [ 1 , 2 , 3 ]
b = [ 4 , 5 , 6 ]
c = [ 4 , 5 , 6 , 7 , 8 ]
zipped = zip ( a, b)
print ( zipped)
print ( list ( zipped) )
zipped = zip ( a, c)
print ( list ( zipped) )
a1, a2 = zip ( * zip ( a, b) )
print ( list ( a1) )
print ( list ( a2) )