列表和字典以及可变集合不能嵌入到集合中,s

作者: 编程  发布:2019-11-21

集合内部的元素,只能存放int, float, str, tuple等必须是可哈希的数据,set类型本身不可哈希

(1)标准类型操作符(所有的集合类型)

5、交集( & )

你可以把交集操作比做集合的 AND(或合取)操作。两个集合的交集是一个新集合,该集合中的每个元素同时是两个集合中的成员,即,属于两个集合的成员。交集符号有一个等价的方法,intersection()。

9159.com 1

3、更新元素:

add()方法:添加一个元素,把参数当做一个元素,不管参数的内容是多少。

>>> b
set([2, 3, 'alex'])
>>> b.add('qiyuanchang')
>>> b
set([2, 3, 'alex', 'qiyuanchang'])

update()方法:会把参数当做一个序列,参数会被拆分成序列添加到集合中,有重复的会被做去重操作。

>>> b
set([2, 3, 'alex', 'qiyuanchang', 'uu', 'u'])
>>> b.update('ops')
>>> b
set([2, 3, 'alex', 'qiyuanchang', 'uu', 'o', 'p', 's', 'u'])    这里会发下参数ops被做了拆分

>>> b.update('wwwwww')
>>> b
set([2, 3, 'alex', 'qiyuanchang', 'uu', 'o', 'p', 's', 'u', 'w'])    这里重复的几个w都被过滤掉了,只保留了一个

>>> li
[2, 3, 'alex']
>>> b=set(li)
>>> b
set([2, 3, 'alex'])
>>> b.update(['12','qiyuanchang'])    当参数是列表的时候,会把列表中的几个元素拆分添加到集合中。
>>> b
set(['12', 2, 3, 'alex', 'qiyuanchang'])

remove()方法:可以删除集合中的指定元素

>>> b
set(['12', 2, 3, 'alex', 'qiyuanchang'])
>>> b.remove(2)
>>> b
set(['12', 3, 'alex', 'qiyuanchang'])

pop()方法:随机删除集合中的元素,测试得知,应该默认会删除第一个集合元素。

>>> b
set(['12', 3, 'alex', 'qiyuanchang'])
>>> b.pop()
'12'

clear()方法:清空集合

>>> b.clear()
>>> b
set([])

del 方法:删除集合

>>> del s
>>> s
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 's' is not defined

 

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

1、len()

把集合作为参数传递给内建函数 len(),返回集合的基数(或元素的个数)。

9159.com 2

日常操作:

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

差补/相对补集( – )两个集合(s 和t)的差补或相对补集是指一个集合C,该集合中的元素,只属于集合s,而不属
于集合t。差符号有一个等价的方法,

7、对称差分( ^ )

和其他的布尔集合操作相似, 对称差分是集合的 XOR(又称”异或“ (exclusive disjunction))。两个集合(s 和 t)的对称差分是指另外一个集合 C,该集合中的元素,只能是属于集合 s 或者集合 t的成员,不能同时属于两个集合。对称差分有一个等价的方法,symmetric_difference()。

9159.com 3

可变集合:可以向集合中添加删除元素,非可哈希的,不能用作字典的键,也不能做其他集合的元素。

把不同的元素组成一起形成集合,集合不记录元素的位置或者插入点,也就是不能用index索引来获取元素。

集合元素:组成集合的成员不可以有重复,有重复的会被筛选过滤。

  • 集合的定义

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

差更新 ( –= )

对集合 s 和 t 进行差更新操作 s-=t,差更新操作会返回一个集合,该集合中的成员是集合 s 去除掉集合 t 中元素后剩余的元素。此方法和 difference_update()等价。

9159.com 4

语法:set()函数

set('list')  参数需要时一个序列

例如:

>>> s = set('alex li')
>>> s
set(['a', ' ', 'e', 'i', 'l', 'x'])  在这里会发现两个l字符,输出时只出现了一次,其中一个重复的被set给筛选过滤掉了。

>> a=[1,2,3,4,5,6]
>>> b=set(a)      当集合被创建后,集合里面的内容就无法在进行修改
>>> b
set([1, 2, 3, 4, 5, 6])

集合对象是一组无序排列的可哈希的值:集合成员可以作为字典的键,列表,字典,元祖这些就是不可哈希的代表。

 

如何查看集合中的数据:

1、通过for循环的方式查看

2、通过迭代器的方式去查看

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

>>> 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'])
(3)集合类型操作符(仅适用于可变集合)
(Union) Update ( |= )
       这个更新方法从已存在的集合中添加(可能多个)成员,此方法和update()等价。

对称差分更新( ^= )

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

9159.com 5

 

 使用大括号,并且里面必须有初始值,否则是dict字典类型

>>> 'k' in t 
True
>>> for i in s: 
...   print i 
...  





s

二、集合的基本操作

4、集合的类型操作符:

  in、not in:可以判断一个元素是否存在于集合中

  >>> s=set('qiyuanchang')
  >>> s1=set('yuan')
  >>> s
  set(['a', 'c', 'g', 'i', 'h', 'n', 'q', 'u', 'y'])
  >>> 'q' in s
  True

  集合等价于不等价(==、!=):判断两个集合是否相同

  子集、超集:判断一个集合的元素内容是否是另外一个集合的子集。

  >>> s=set('qiyuanchang')
  >>> s1=set('yuan')
  >>> s1 < s
  True

  联合:联合操作与集合的or操作其实是等价的,联合符号有个等价的方法,union()

  交集:

  差集:

 

集合内部的元素无序,所以不能使用索引、切片等操作

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

三、集合可用的内建函数

1、创建集合:由于集合没有自己的语法格式,只能通过集合的工厂方法set()和forzenset()来创建。

>>> set("[1,2,3,4,5]")
set([',', '1', '3', '2', '5', '4', '[', ']'])

并集union

type(obj)--返回对象的类型

6、差补/相对补集( – )

两个集合(s 和 t)的差补或相对补集是指一个集合 C,该集合中的元素,只属于集合 s,而不属于集合 t。差符号有一个等价的方法,difference()。

9159.com 6

2、访问集合:由于集合本身是无序的,所以不能为集合创建索引或切片操作,只能通过循环遍历或使用用in、not in 来访问或者判断集合元素。

>>> b
set([1, 2, 3, 4, 5, 6])
>>> 2 in b
True

>>> li = [2,3,'alex']
>>> li
[2, 3, 'alex']
>>> b=set(li)
>>> b
set([2, 3, 'alex'])
>>> 'alex' in b
True
>>> 'ale' in b    通过这里可以发现‘alex’在集合中是作为一个整体的,不是作为一个字符串可以进行分开匹配。
False

  • 集合的特征

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

2、集合等价/不等价

等价/不等价被用于在相同或不同的集合之间做比较。两个集合相等是指,对每个集合而言,两个集合中的成员完全相同。集合等价/不等价与集合的类型或集合成员的顺序无关,只与集合的元素有关。

9159.com 7

不可变集合:不可以向集合中添加删除元素,非可哈希的,不能用作字典的键,也不能做其他集合的元素。

交集intersection

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

一、集合

这表示无序的,有限的,不重复的对象集合。因为是无序的,所以它们不能被任何下标索引。一个集合的行为很像一个无值的字典的键,但是它还支持额外的操作。集合只能包含不可变的对象类型,列表和字典以及可变集合不能嵌入到集合中。

和其他容器类型一样,集合支持用 in 和 not in 操作符检查成员,由 len() 内建函数得到集合的基数(大小),用 for 循环迭代集合的成员。但是因为集合本身是无序的,你不可以为集合创建索引或执行切片(slice)操作,也没有键(keys)可用来获取集合中元素的值。

集合(sets)有两种不同的类型,可变集合(set) 和 不可变集合(frozenset)。如你所想,对可变集合(set),你可以添加和删除元素,对不可变集合(frozenset)则不允许这样做。请注意,可变集合(set)不是可哈希的,因此既不能用做字典的键也不能做其他集合中的元素。不可变集合(frozenset)则正好相反,即,他们有哈希值,能被用做字典的键或是作为集合中的一个成员。

集合的常用用法是快速成员测试,从序列中去除重复,以及计算数学运算,例如:交集、并集、差集。

对于集合元素,相同的不变性规则适用于字典的键。注意,数值类型遵循正常的数值比较规则:如果两个数字相等(例如,1和1.0),其中只有一个可以包含在集合中。

集合 set:可变集合与不可变集合

集合内部的元素具有唯一性,不允许元素重复出现

    对象值的比较

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

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是无序的

obj1 is obj2  --obj 与obj2是同一个对象  return True False

3、子集/超集

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

“小于” 和 “大于”意味着两个集合在比较时不能相等。等于号允许非严格定义的子集和超集。

Sets 支持严格( < )子集和非严格 ( <= ) 子集,也支持严格( > )超集和非严格 ( >= )超集。只有当第一个集合是第二个集合的严格子集时,我们才称第一个集合“小于”第二个集合,同理,只有当第一个集合是第二个集合的严格超集时,我们才称第一个集合“大于”第二个集合。

9159.com 8

子集issubset:检查一个集合是否为另一个集合的子集

实例:

1、成员关系 (in, not in)

Python 中的 in 和 not in 操作符决定某个元素是否是一个集合中的成员。

9159.com 9

差集difference

成员关系 (in, not in)

4、联合( | )

联合(union)操作和集合的 OR(又称可兼析取(inclusive disjunction))其实是等价的,两个集合的联合是一个新集合,该集合中的每个元素都至少是其中一个集合的成员,即,属于两个集合其中之一的成员。联合符号有一个等价的方法,union()。

9159.com 10

  •  冰冻集合

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

(Union) Update ( |= )

这个更新方法从已存在的集合中添加(可能多个)成员,此方法和 update()等价。

9159.com 11

  •  多循环的集合内涵

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

    s3 = {m * n for m in s2 for n in s1} #相当于把s2中的每个元素乘以1/2/3 print(s3) #输出{'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删除不存在的元素不报错,只是删除失败而已

  • 交叉并补

             and

4、删除集合

如果如何删除集合本身,可以像删除任何 Python 对象一样,令集合超出它的作用范围, 或调用 del() 将他们直接清除出当前的名字空间。 如果它的引用计数为零,也会被标记以便被垃圾回收。

9159.com 12

不可以进行任何修改操作的集合,其他属性与集合完全一致。

保留(或交集更新)操作保留与其他集合的共有成员,此方法和 intersection_update()等价。
差更新 ( –= )

二、集合类型操作符

超集issuperset:检查一个集合是否为另一个集合的超集(如果一个集合S2中的每一个元素都在集合S1中,且集合S1中可能包含S2中没有的元素,则集合S1就是S2的一个超集,反过来,S2是S1的子集)

(2)如何访问集合中的值
       可以遍历查看集合成员或检查某项元素是否是一个集合中的成员。

2、set() and frozenset()

set() 和 frozenset() 工厂函数分别用来生成可变和不可变的集合。如果不提供任何参数,默认会生成空集合。如果提供一个参数,则该参数必须是可迭代的,即,一个序列,或迭代器,或支持迭代的一个对象,例如:一个文件或一个字典。

9159.com 13

del s

3、更新集合

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

9159.com 14

cmp(obj1, obj2)--1>2 return i>0
 
          1<2 return i<0
 
          1==2 return i=0
repr(obj)/repr('obj')--返回一个对象的字符串表示

保留/交集更新( &= )

保留(或交集更新)操作保留与其他集合的共有成员。此方法和 intersection_update()等价。

9159.com 15

保留/交集更新( &= )

1、创建集合类型

集合与列表( [ ] )和字典( { } ) 一样,可以使用内置函数创建也可以使用操作符来创建。我们可以使用和字典一样的花括号({})来创建集合(可变),也可以使用向内置函数 set()frozenset() 传递一个序列或其他的可迭代的对象分别来创建可变集合和不可变集合。

不管如何创建集合,Python都是用常量格式 {1, 2, 3}(对于可变集合来说)来显示它,要创建空的集合或从已有的可迭代对象构建集合,还是需要内置的set()函数(直接使用空的花括号默认创建的是空字典)但是使用花括号操作符创建集合便于初始化具有已知结构的集合。

9159.com 16

    对象身份的比较

2、访问集合中的值

你可以遍历查看集合成员或检查某项元素是否是一个集合中的成员。

9159.com 17

difference(). 
>>> s - t 
set(['c', 'e']) 
对称差分( ^ ):对称差分是集合的XOR以上文章就是Python字典对集合类型的实际应用步骤

集合类型的实际操作:

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

            or
--实现功能为逻辑 非 与 或

>>> s.add('z') 
>>> s 
set(['c', 'e', 'h', 'o', 'p', 's', 'z']) 
>>> s.update('pypi') 
>>> s 
9159.com,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'])  

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

(2)集合类型操作符(所有的集合类型)
联合( | )
        联合(union)操作和集合的 OR(又称可兼析取(inclusive disjunction))其实是等价的,两个集合的联合是一个新集合,该集合中的每个元素都至少是其中一个集合的成员,即属于两个集合其中之一的成员。联合符号有一个等价的方法:union()。
交集( & )
       可以把交集操作比做集合的AND(或合取)操作。两个集合的交集是一个新集合,该集合中的每个元素同时是两个集合中的成员,即属于两个集合的成员。交集符号有一个等价的方法:intersection()。
差补/相对补集( – )
        两个集合(s 和 t)的差补或相对补集是指一个集合 C,该集合中的元素,只属于集合 s,而不属于集合 t。差符号有一个等价的方法:difference()。
对称差分( ^ )
       和其他的布尔集合操作相似,对称差分是集合的XOR(又称“异或” (exclusive disjunction))。两个集合(s 和 t)的对称差分是指另外一个集合C,该集合中的元素,只能是属于集合 s 或者集合t的成员,不能同时属于两个集合。对称差分有一个等价的方法:symmetric_difference()。
混合集合类型操作
        如果左右两个操作数的类型相同,既都是可变集合或不可变集合,则所产生的结果类型是相同的。但如果左右两个操作数的类型不相同(左操作数是 set,右操作数是 frozenset,或相反情况),则所产生的结果类型与左操作数的类型相同 。

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

(4)如何删除集合中的成员和集合
        删除集合成员remove()内建方法。删除集合本身,可以像删除任何Python对象一样,令集合超出它的作用范围或调用del将它们直接清除出当前的名字空间。如果它的引用计数为零,也会被标记以便被垃圾回收。如del s。

(1)如何创建集合类型和给集合赋值
        集合与列表( [ ] )和字典( { } ) 不同,没有特别的语法格式。列表和字典可以分别用他们自己的工厂方法 list() 和 dict() 创建,这也是集合被创建的唯一方法:用集合的工厂方法set()和frozenset()。

(3)如何更新集合
         用各种集合内建的方法和操作符添加和删除集合的成员。只有可变集合能被修改,试图修改不可变集合会引发异常。

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

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

 

       注意:加号不是集合类型的运算符。

>>> 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

任何相同类型的对象都可以比较,格式为:a == b,在python2.3之前类型不具有布尔值,返回值为1 0;2.3版本之后返回只为 True False

成员关系 (in, not in)
        就序列而言,Python中的in和not in操作符决定某个元素是否是一个集合中的成员。
集合等价/不等价
        等价/不等价被用于在相同或不同的集合之间做比较。两个集合相等是指,对每个集合而言,当且仅当其中一个集合中的每个成员同时也是另一个集合中的成员。也可以说每个集合必须是另一个集合的一个子集, 即s <= t 和s>= t 的值均为真(True),或(s <= t and s>= t) 的值为真(True)。集合等价/不等价与集合的类型或集合成员的顺序无关,只与集合的元素有关。
子集/超集
        set用Python的比较操作符检查某集合是否是其他集合的超集或子集。“小于”符号(<、<=)用来判断子集,“大于”符号(>、 >= )用来判断超集。“小于” 和 “大于”意味着两个集合在比较时不能相等。等于号允许非严格定义的子集和超集。
        set支持严格( < )子集和非严格 ( <= ) 子集,也支持严格( > )超集和非严格 ( >= )超集。只有当第一个集合是第二个集合的严格子集时,我们才称第一个集合“小于”第二个集合。同理,只有当第一个集合是第二个集合的严格超集时,我们才称第一个集合“大于”第二个集合。

删除集合

obj1 is not obj2 --obj 与obj2是同一个对象  return True False

集合等价/不等价

对集合s和t进行差更新操作s-=t,差更新操作会返回一个集合,该集合中的成员是集合s去除掉集合t中元素后剩余的元素。此方法

标准类型的内建函数

>>> 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'>
如何更新集合用各种集合内建的方法和操作符添加和删除集合的成员:

本文由9159.com发布于编程,转载请注明出处:列表和字典以及可变集合不能嵌入到集合中,s

关键词: