Python基础手册1四,Python中的集合类型操作符例子

By admin in 4858.com on 2019年4月14日
  • 聚拢的定义

(一)标准项目操作符(全数的成团类型)

一、集合

那表示严节的,有限的,不另行的目的集合。因为是严节的,所以它们无法被其余下标索引。1个成团的表现很像多个无值的字典的键,不过它还协助额外的操作。集合只好分包不可变的对象类型,列表和字典以及可变集合不可能松手到集结中。

和别的容器类型1样,集合协助用 in 和 not in 操作符检查成员,由 len()
内建函数到手集合的基数(大小),用 for
循环迭代集合的成员。可是因为集合本人是冬季的,你不可以为汇聚创造索引或执行切片(slice)操作,也向来不键(keys)可用来赢得集合七月素的值。

集聚(sets)有二种分裂的花色,可变集合(set) 和
不可变集合(frozenset)。如你所想,对可变集合(set),你能够加上和删除成分,对不可变集合(frozenset)则分裂意那样做。请留意,可变集合(set)不是可哈希的,因此既不能够用做字典的键也无法做别的集合中的成分。不可变集合(frozenset)则刚好相反,即,他们有哈希值,能被用做字典的键或是作为集合中的1个分子。

聚集的常用用法是便捷成员测试,从种类中去除重复,以及总结数学生运动算,例如:交集、并集、差集。

对此集合成分,相同的不变性规则适用于字典的键。注意,数值类型遵守通常的数值比较规则:假使多少个数字约等于(例如,1和一.0),当中唯有七个方可分包在汇集中。

1 字典基础操作

 使用大括号,并且个中必须有先导值,不然是dict字典类型

分子涉及 (in, not in)
        就系列而言,Python中的in和not
in操作符决定有个别成分是不是是一个相会中的成员。
聚拢等价/不等价
       
等价/不等价被用于在同等或差异的集结之间做相比较。八个汇集相等是指,对每一种集合而言,当且仅当在这之中一个汇聚中的各类成员同时也是另三个集聚中的成员。也足以说每一种集合必须是另1个集结的三个子集,
即s <= t 和s>= t 的值均为真(True),或(s <= t and s>= t)
的值为真(True)。集合等价/不等价与聚集的档次或集合成员的次第非亲非故,只与聚集的要素有关。
子集/超集
       
set用Python的相比较操作符检查某集合是不是是别的集合的超集或子集。“小于”符号(<、<=)用来判定子集,“大于”符号(>、
>= )用来判定超集。“小于” 和
“大于”意味着几个集聚在比较时无法等于。等于号允许非严加定义的子集和超集。
        set帮忙严厉( < )子集和非严俊 ( <= ) 子集,也帮衬严刻( >
)超集和非严谨 ( >=
)超集。唯有当第2个汇聚是第一个聚众的从严子集时,大家才称第二个汇集“小于”第三个聚众。同理,唯有当第3个集聚是第三个聚众的严酷超集时,大家才称第3个集聚“大于”第1个聚众。

2、集合的基本操作

一.1 创设字典

  • 通过{}操作符创造字典
    aDict = {'name':'ke', 'age':25}
  • 通过dict()工厂方法创制字典
    bDict = dict((['name', 'ke'], ['age', 25]))
  • 通过fromkeys()创设具有同样值得默许字典
    cDict = {}.fromkeys(('ke', 'alice'), 23)
  • 集聚的表征

Python基础手册1四,Python中的集合类型操作符例子。    对象值的可比

壹、创建集合类型

集合与列表( [ ] )和字典( { } )
1样,能够行使内置函数成立也得以行使操作符来创设。大家能够动用和字典壹样的花括号({})来创制集合(可变),也得以选择向内置函数
set()frozenset()
传递2个队列或其余的可迭代的靶子分别来创设可变集合和不可变集合。

不管怎么样创立集合,Python都以用常量格式 {一, 二,
3}(对于可变集合来说)来展示它,要创造空的集聚或从已有的可迭代对象创设集合,照旧需求停放的set()函数(直接使用空的花括号默许成立的是空字典)不过采用花括号操作符创立集合便于开头化具有已知结构的联谊。

4858.com 1

一.2 访问字典

  • 字典是炫耀类型,意味着它并未有下标,访问字典中的值须求利用相应的值

>>> for eachKey in aDict:
...     print 'key=%s, value=%s' % (eachKey, aDict[eachKey])
...
key=age, value=25
key=name, value=ke
>>> print '%(name)s' % aDict
ke

聚拢内部的成分冬季,所以不能够应用索引、切片等操作

其它壹样档次的靶子都足以相比较,格式为:a ==
b,在python2.三事先类型不抱有布尔值,重临值为一 0;二.3版本之后回来只为
True False

2、访问集合中的值

您能够遍历查看集合成员或检查某项成分是还是不是是贰个成团中的成员。

4858.com 2

一.三 更新字典

  • 通过键更新字典
    • 一旦字典中有该键,则更新相关值
      4858.com ,-若是字典中尚无该键,则向字典中添加新值

>>> print aDict
{'age': 25, 'name': 'ke'}
>>> aDict['age'] = 22
>>> print aDict
{'age': 22, 'name': 'ke'}
>>> aDict['email']='allenouyangke@icloud.com'
>>> print aDict
{'age': 22, 'name': 'ke', 'email': 'allenouyangke@icloud.com'}
>>>

集聚内部的因素具有唯1性,不容许成分重复出现

    对象身份的可比

三、更新集合

用集合内建的艺术和操作符添加和删除集合的成员。

4858.com 3

1.四 删除字典

  • 通过del能够去除字典中的成分或任何字典
  • 采纳个中方法clear()可以清空字典
  • 使用pop()主意能够“弹出”字典中的成分

>>> del aDict['email']
>>> print aDict
{'age': 22, 'name': 'ke'}
>>> aDict.pop('age')
22
>>> print aDict
{'name': 'ke'}
>>> aDict.clear()
>>> print aDict
{}

聚集内部的要素,只可以存放int, float, str,
tuple等必须是可哈希的多少,set类型笔者不可哈希

obj一 is obj二  –obj 与obj2是同一个指标  return True False

4、删除集合

要是什么删除集合自个儿,能够像删除任何 Python
对象一样,令集合超出它的功力范围, 或调用 del()
将她们径直铲除出当下的名字空间。
假如它的引用计数为零,也会被标记以便被垃圾回收。

4858.com 4

一.5 字典操作符

  • 运用字典键查找操作符号[],查找键所对应的值
  • 使用innot in判断键是还是不是存在于字典中

>>> aDict = {'name': 'ke', 'age': 25}
>>> print aDict
{'age': 25, 'name': 'ke'}
>>> 'name' in aDict
True
>>> 'ke' in aDict
False
>>>

s1 = {1,2,3,'a','b','c',7,8,9}
s2 = {}

print(type(s1)) #输出<class 'set'>
print(type(s2)) #输出<class 'dict'>

for i in s1:
    print(i,end=' ') #输出1 2 3 b 7 8 9 a c,可见set是无序的

obj壹 is not obj二 –obj 与obj二是同贰个对象  return True False

二、集合类型操作符

2 字典相关函数

  •  多循环的成团内涵

    s1 = {1,2,3}
    s2 = {‘i’, ‘love’, ‘you’}

    s3 = {m * n for m in s二 for n in s壹} #相当于把s第22中学的各样元素乘以八分之四/三print(s三) #输出{‘iii’, ‘lovelove’, ‘you’, ‘youyou’, ‘i’, ‘youyouyou’, ‘ii’, ‘love’, ‘lovelovelove’}

  •  删除成分

    s = {‘a’,’b’,’c’,’d’,’e’,’f’}
    # s.remove(‘k’) #remove删除不设有的成分报错keyerror
    s.discard(‘k’) #discard删除不存在的因素不报错,只是删除退步而已

  • 六续并补

    布尔类型–python中的与、或、非

一、成员涉及 (in, not in)

Python 中的 in 和 not in 操作符决定某些元素是或不是是一个成团中的成员。

4858.com 5

二.壹 功效于字典的函数

  • len():重回字典瓜时素的数量
  • hash():本人不是为字典设计的,可是足以判定有些对象是或不是能够看作字典的键

>>> print aDict
{'age': 25, 'name': 'ke'}
>>> len(aDict)
2
>>> hash(3)
3
>>> hash([])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>>

交集intersection

布尔类型的预先级依次为:not

贰、集合等价/不等价

等价/不等价被用于在平等或区别的成团之间做相比。八个汇集相等是指,对各种集合而言,四个聚众中的成员完全相同。集合等价/不等价与聚集的品类或集合成员的依次非亲非故,只与聚集的因素有关。

4858.com 6

2.二 字典内建办法

  • dict.copy():重回字典(浅复制)的二个副本

>>> print aDict
{'age': 25, 'name': 'ke'}
>>> bDict = aDict.copy()
>>> print bDict
{'age': 25, 'name': 'ke'}
>>> bDict['name'] = 'yuyu'
>>> print bDict
{'age': 25, 'name': 'yuyu'}
>>> print aDict
{'age': 25, 'name': 'ke'}
>>>
  • dict.get(key, default=None):对字典dict中的键key,重返它对应的值value,假使字典中不存在此键,则赶回default的值

>>> print aDict
{'age': 25, 'name': 'KE'}
>>> aDict.get('name', 'not found')
'KE'
>>> aDict.get('email', 'not found')
'not found'
>>>
  • dict.setdefault(key, default=None):假诺字典中不设有key键,由dict[key]=default为它赋值

>>> print aDict
{'age': 25, 'name': 'KE'}
>>> aDict.setdefault('age', 20)
25
>>> aDict.setdefault('iphone', 13570319584)
13570319584
>>> print aDict
{'age': 25, 'name': 'KE', 'iphone': 13570319584}
>>>
  • dict.items():重回2个含有字典中(键,值)对元组的列表
  • dict.keys():重返3个饱含字典中键的列表
  • dict.values():重临2个暗含字典中颇具值得列表
  • dict.update(dict2):将字典dict2的键-值对增进到字典dict

差集difference

             and

3、子集/超集

Sets 用 Python
的相比较操作符检查某集合是或不是是其余集合的超集或子集。“小于”符号( <,
<= )用来判断子集,“大于”符号( >, >= )用来判断超集。

“小于” 和
“大于”意味着多少个集聚在比较时不能够等于。等于号允许非严加定义的子集和超集。

Sets 帮助严俊( < )子集和非严俊 ( <= ) 子集,也支撑严厉( >
)超集和非严苛 ( >=
)超集。唯有当第三个汇聚是首个汇聚的严加子集时,大家才称第二个聚众“小于”第1个汇聚,同理,唯有当第二个汇集是第叁个聚众的严酷超集时,大家才称第三个汇集“大于”第3个聚众。

4858.com 7

3 集合

并集union

            or
–完毕效益为逻辑 非 与 或

4、联合( | )

一路(union)操作和集合的 O奔驰G级(又称可兼析取(inclusive
disjunction))其实是等价的,五个集聚的一道是三个新集合,该集合中的每一种成分都至少是里面三个集合的分子,即,属于三个聚众当中之一的成员。联合符号有2个格外的办法,union()。

4858.com 8

三.1 集合类型

  • 数学上,把set名称为由不一致的要素构成的成团,集合(set)的积极分子平日被称作集合元素
  • 构成目的是一组冬日排列的可哈希的值
  • 会合有两类别型:
    • 可变集合set
    • 不可变集合frozenset

>>> s1 = set('hello')
>>> s2 = frozenset('hello2')
>>> s1
set(['h', 'e', 'l', 'o'])
>>> s2
frozenset(['h', '2', 'e', 'l', 'o'])
>>>

子集issubset:检查三个相会是不是为另一个晤面的子集

专业项目标内建函数

5、交集( & )

你能够把交集操作比做集合的
AND(或合取)操作。多少个集聚的以次充好是2个新集合,该集合中的种种成分同时是三个集聚中的成员,即,属于三个汇聚的分子。交集符号有三个相当于的法子,intersection()。

4858.com 9

3.二 集合类型操作符

  • 集合帮忙用innot in操作符检查成员
  • 能够透过len()自小编批评集合大小
  • 可见采用for迭代集结成员
  • 无法展开切开,没有键
  • |:联合,取并值
  • &:交集
  • =:差补

超集issuperset:检查一个凑合是不是为另三个汇合的超集(假使3个集合S2中的每叁个因素都在集合S第11中学,且集合S第11中学可能含蓄S第22中学尚无的要素,则集合S一正是S2的3个超集,反过来,S二是S壹的子集)

cmp(obj1, obj2)–1>2 return i>0
 
          1<2 return i<0
 
          1==2 return i=0
repr(obj)/repr(‘obj’)–重回多个对象的字符串表示

陆、差补/绝对补集( – )

八个集聚(s 和 t)的差补或相对补集是指二个成团
C,该集合中的成分,只属于集合 s,而不属于集合
t。差符号有1个对等的秘籍,difference()。

4858.com 10

3.三 集合内建办法

  • set.add():添加成员
  • set.update():批量添加成员
  • set.remove():移除成员
  • s.issubset(t):借使s是t的子集,则赶回True,不然再次来到False
  • s.issuperset(t):若是t是s的超集,则赶回True,不然返回False
  • s.union(t):再次回到2个新集合,该集合是s和t的并集
  • s.intersection(t):重回三个新集合,该集合是s和t的搅和
  • s.difference(t):再次来到叁个新集合,该集合是s的积极分子,但不是t的积极分子

s1 = {1,2,3,4,5,6}
s2 = {5,6,7,8,9,0}

s3 = s1.intersection(s2) #s1与s2的交集
print(s3) #输出{5, 6}

s4 = s1.difference(s2) #s1与s2的差集,相当于s1-s2
print(s4) #输出{1, 2, 3, 4}

s5 = s1.union(s2) #s1与s2的并集
print(s5) #输出{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

i1 = s1.issubset(s2) #判断s2是否为s1的子集,i1为False
i2 = s1.issuperset(s2) #判断s2是否为s1的超集,i2为False

str(obj)–重返对象可读性好的字符串表示

七、对称差分( ^ )

和其余的布尔集合操作相似, 对称差分是会合的 XO瑞鹰(又称”异或“ (exclusive
disjunction))。四个集聚(s 和 t)的对称差分是指别的贰个集结
C,该集合中的成分,只可以是属于集合 s 也许聚众
t的分子,无法同时属于三个聚众。对称差分有七个分外的方法,symmetric_difference()。

4858.com 11

  •  冰冻集合

type(obj)–重回对象的连串

八、联合操作符(仅适用于可变集合)

不可以实行任何改动操作的成团,别的属性与聚集完全一致。

(二)集合类型操作符(全数的会面类型)
联合( | )
        联合(union)操作和汇聚的 O瑞鹰(又称可兼析取(inclusive
disjunction))其实是等价的,五个汇聚的同步是3个新集合,该集合中的每一种成分都至少是里面1个聚众的成员,即属于多少个聚众在那之中之一的分子。联合符号有2个特出的办法:union()。
交集( & )
      
可以把交集操作比做集合的AND(或合取)操作。多少个汇聚的混合是二个新集合,该集合中的每一个元素同时是四个聚众中的成员,即属于四个集聚的成员。交集符号有2个也就是的办法:intersection()。
差补/绝对补集( – )
        多少个汇集(s 和 t)的差补或绝对补集是指一个集聚C,该集合中的成分,只属于集合 s,而不属于集合
t。差符号有七个格外的艺术:difference()。
对称差分( ^ )
       和其他的布尔集合操作相似,对称差分是聚众的XO奥德赛(又称“异或”
(exclusive disjunction))。多个汇聚(s 和
t)的相辅相成差分是指其它3个集合C,该集合中的成分,只好是属于集合 s
也许集合t的成员,不能够而且属于七个集聚。对称差分有3个对等的点子:symmetric_difference()。
掺杂集合类型操作
       
假如左右三个操作数的档次相同,既都以可变集合或不可变集合,则所发生的结果类型是壹律的。但借使左右三个操作数的品类不平等(左操作数是
set,右操作数是
frozenset,或相反情形),则所发生的结果类型与左操作数的品种相同 。

(Union) Update ( |= )

其1创新方法从已存在的会见中加上(只怕多少个)成员,此格局和 update()等价。

4858.com 12

s = {1,2,3}
s = frozenset(s)
print(s) #输出frozenset({1, 2, 3})

       注意:加号不是汇聚类型的运算符。

保存/交集更新( &= )

保存(或混合更新)操作保留与任何集合的共有成员。此办法和
intersection_update()等价。

4858.com 13

 

>>> t | s 
frozenset([‘c’, ‘b’, ‘e’, ‘h’, ‘k’, ‘o’, ‘p’, ‘s’]) 
>>> t ^ s 
frozenset([‘c’, ‘b’, ‘e’, ‘k’, ‘p’]) 
>>> s | t 
set([‘c’, ‘b’, ‘e’, ‘h’, ‘k’, ‘o’, ‘p’, ‘s’]) 
>>> s ^ t 
set([‘p’, ‘b’, ‘e’, ‘k’, ‘c’])
(三)集合类型操作符(仅适用于可变集合)
(Union) Update ( |= )
      
那一个创新方法从已存在的集聚中拉长(只怕多个)成员,此措施和update()等价。

差更新 ( –= )

对聚集 s 和 t 举行差更新操作
s-=t,差更新操作会重回三个晤面,该集合中的成员是聚众 s 去除掉集合 t
桐月素后剩余的要素。此办法和 difference_update()等价。

4858.com 14

>>> s = set(‘cheeseshop’) 
>>> s |= set(‘pypi’) 
>>> s 
set([‘c’, ‘e’, ‘i’, ‘h’, ‘o’, ‘p’, ‘s’, ‘y’])

对称差分更新( ^= )

对聚集 s 和 t
进行对称差分更新操作(s^=t),对称差分更新操作会重回贰个会见,该集合中的成员仅是原集合
s 或仅是另壹集合 t 中的成员。此方法和
symmetric_difference_update()等价。

4858.com 15

保存/交集更新( &= )

三、集合可用的内建函数

保存(或混合更新)操作保留与别的集合的共有成员,此办法和
intersection_update()等价。
差更新 ( –= )

1、len()

把集同盟为参数字传送递给内建函数 len(),再次回到集合的基数(或因素的个数)。

4858.com 16

对集合s和t进行差更新操作s-=t,差更新操作会再次回到贰个聚集,该集合中的成员是集合s去除掉集合t瓜月素后剩余的因素。此办法

2、set() and frozenset()

set() 和 frozenset()
工厂函数分别用来生成可变和不可变的集纳。若是不提供别的参数,暗中同意会生成空集合。假设提供一个参数,则该参数必须是可迭代的,即,三个队列,或迭代器,或帮忙迭代的三个指标,例如:叁个文书或贰个字典。

4858.com 17

和difference_update()等价。
对称差分更新( ^= )

对集合s和t实行对称差分更新操作(s^=t),对称差分更新操作会重临1个汇聚,该集合中的成员仅是原集合s或仅是另一集合t中的成员。此方法和symmetric_difference_update()等价

 

晤面类型的实操:

(一)怎么着成立集合类型和给集合赋值
        集合与列表( [ ] )和字典( { } )
不一致,未有专门的语法格式。列表和字典能够独家用他们本人的厂子方法 list()
和 dict()
成立,那也是会见被创造的绝无仅有办法:用集合的厂子方法set()和frozenset()。

>>> s = set(‘cheeseshop’) 
>>> s 
set([‘c’, ‘e’, ‘h’, ‘o’, ‘p’, ‘s’]) 
>>> t = frozenset(‘bookshop’) 
>>> t 
frozenset([‘b’, ‘h’, ‘k’, ‘o’, ‘p’, ‘s’]) 
>>> len(s), len(t) 
(6, 6) 
>>> s == t 
False

(2)怎么着访问集合中的值
       能够遍历查看集合成员或检查某项成分是不是是一个集结中的成员。

>>> ‘k’ in t 
True
>>> for i in s: 
…   print i 
…  





s

(3)怎样翻新集合
        
用各个集合内建的法子和操作符添加和删除集合的分子。惟有可变集合能被修改,试图修改不可变集合会引发那些。

[html] view plaincopy在CODE上查看代码片派生到本人的代码片

>>> s.add(‘z’) 
>>> s 
set([‘c’, ‘e’, ‘h’, ‘o’, ‘p’, ‘s’, ‘z’]) 
>>> s.update(‘pypi’) 
>>> s 
set([‘c’, ‘e’, ‘i’, ‘h’, ‘o’, ‘p’, ‘s’, ‘y’, ‘z’]) 
>>> s.remove(‘z’) 
>>> s -= set(‘pypi’) 
>>> s 
set([‘c’, ‘e’, ‘h’, ‘o’, ‘s’])

(四)怎样删除集合中的成员和聚众
       
删除集合成员remove()内建艺术。删除集合本身,能够像删除任何Python对象1样,令集合超出它的功能范围或调用del将它们平素铲除出当下的名字空间。借使它的引用计数为零,也会被标记以便被垃圾回收。如del
s。

实例:

用集合的厂子方法 set()和 frozenset():

>>> s = set(‘cheeseshop’) 
>>> s 
set([‘c’, ‘e’, ‘h’, ‘o’, ‘p’, ‘s’]) 
>>> t = frozenset(‘bookshop’) 
>>> t 
frozenset([‘b’, ‘h’, ‘k’, ‘o’, ‘p’, ‘s’]) 
>>> type(s) 
<type ‘set’> 
>>> type(t) 
<type ‘frozenset’>
怎么样翻新集合用各类集合内建的点子和操作符添加和删除集合的积极分子:

>>> s.add(‘z’) 
>>> s 
set([‘c’, ‘e’, ‘h’, ‘o’, ‘p’, ‘s’, ‘z’]) 
>>> s.update(‘pypi’) 
>>> s 
set([‘c’, ‘e’, ‘i’, ‘h’, ‘o’, ‘p’, ‘s’, ‘y’, ‘z’]) 
>>> s.remove(‘z’) 
>>> s 
set([‘c’, ‘e’, ‘i’, ‘h’, ‘o’, ‘p’, ‘s’, ‘y’]) 
>>> s -= set(‘pypi’) 
>>> s 
set([‘c’, ‘e’, ‘h’, ‘o’, ‘s’])
 

除去集合

del s

成员涉及 (in, not in)

>>> s = set(‘cheeseshop’) 
>>> t = frozenset(‘bookshop’) 
>>> ‘k’ in s 
False
>>> ‘k’ in t 
True
>>> ‘c’ not in t 
True

聚集等价/不等价

>>> s == t 
False
>>> s != t 
True
>>> u = frozenset(s) 
>>> s == u 
True
>>> set(‘posh’) == set(‘shop’) 
True

差补/相对补集( – )八个集聚(s
和t)的差补或相对补集是指二个集合C,该集合中的成分,只属于集合s,而不属
于集合t。差符号有一个对等的不二等秘书籍,

difference(). 
>>> s – t 
set([‘c’, ‘e’]) 
对称差分( ^
):对称差分是相会的XO悍马H二以上小说正是Python字典对聚集类型的莫过于行使步骤

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有