python中的集合set类型是可变的吗_[Python] Python数据类型(三）集合类型之set集合和frozenset集合...

1.集合基本概念

集合是0-n个对象引用的无序组合，集合中存储的元素不可重复，因此这些对象引用的引用的对象必须是可哈希运算的 。  1.python中提供了两种内置的集合类型：可变的set类型和固定的frozenset类型。  2.只有可哈希运算的对象可以添加到集合中，因为集合是无序的，不能存储重复数据项；  3.可哈希运算的对象包含一个__hash__()方法，该方法返回值在整个对象的生命周期都是相同的，可以使用__eq__()方法进行比较。  4.所有内置的固定数据类型都是可哈希运算的，比如：int,float,str,tuple,所有内置的可变的数据类型都是不可进行哈希运算的，比如：dict,list,set.  5.集合中不存储重复元组，每一项都是唯一的。

2.set集合

set类型是可变的无序序列，因此可以进行添加、移除数据，同时由于是无序的组合类型，因此没有索引位置 ，故不能使用分片操作符进行操作。

2.1.set的创建

1.创建set类型时，使用{}进行创建，如：

>>> s1 = {"java","12",12}

>>> s1

{'12', 12, 'java'}

str、int都是内置不可变的数据类型，因此可以存储在set集合中，如果存储list类型的数据项呢？

>>> l1 = [1,2,3]

>>> s1 = {"java",12,l1}

Traceback (most recent call last):

File "", line 1, in

s1 = {"java",12,l1}

TypeError: unhashable type: 'list'

这里报TypeError异常，原因是list是可变类型，没有hash()方法，不能进行哈希运算，因此 不能存储在set中。

2.使用set()创建集合，set()将返回一个空集合：

>>> s = set()

>>> s

set()

>>>

set()中传入一个set参数时，将返回该set的浅拷贝：

>>> s = set(s1)

>>> s

{'12', 12, 'java'}

>>>

set()中如果传入其他任意对象，则尝试将给定的对象转换为集合：

>>> s = set("set list")

>>> s

{' ', 's', 'l', 't', 'e', 'i'}

>>>

注意：创建空集合时，只能必须用set().不能使用s = {“ss”,1}这种形式，原因是这种形式用于创建另一种数据类型dict.

3.使用集合内涵创建(单独总结)

2.2.常用操作符和方法：

,<=,>=,==,!=:比较运算符,逐项进行比较，如果有嵌套，则递归比较；  如：

>>> s1 = set("1234")

>>> s2 = set("2134")

>>> s1

{'2', '3', '1', '4'}

>>> s2

{'2', '3', '1', '4'}

>>>

>>> s1 == s2

True

>>>

in、not in：成员关系符：

>>> "2" in s2

True

>>>

内置len()方法：

>>> len(s1)

4

>>>

集合操作符：|，&，-，^,  |:并集

>>> s1 = set("man")

>>> s2 = set("woman")

>>> s1 | s2

{'o', 'n', 'a', 'w', 'm'}

>>>

&：交集

>>> s1 & s2

{'m', 'n', 'a'}

>>>

-：如A-B,表示包含A中但不包含B中元素组成的集合，不支持交换性，如

>>> s1 - s2

set()

>>> s2 -s1

{'o', 'w'}

>>>

^:对称差集，A&B以外的元素组成的集合

>>> s2 ^ s1

{'o', 'w'}

>>>

常用方法：  s.add(x):将数据项x添加到集合s中  s.clear():清空s集合  s.copy()返回s的浅拷贝  s.difference(t):返回一个新集合，包含s中数据项但不包含t中的数据项，等同s-t,如：

>>> s1 = set("chinese")

>>> s2 = set("china")

>>> s1.difference(s2)

{'s', 'e'}

>>> s2.difference(s1)

{'a'}

>>>

s.difference-update(t):移除s中和t中都存在的数据项，等同于s-=t

>>> s1

{'h', 'n', 's', 'c', 'e', 'i'}

>>> s2

{'h', 'n', 'a', 'c', 'i'}

>>>

>>> s1.difference_update(s2)

>>> s1

{'s', 'e'}

>>>

s.discard(x):从集合s中移除数据项x，如果不存在，则不进行操作：

>>> s = set("discard")

>>> s

{'d', 'a', 's', 'r', 'c', 'i'}

>>> s.discard("s")

>>> s

{'d', 'a', 'r', 'c', 'i'}

>>> s.discard("y")

>>> s

{'d', 'a', 'r', 'c', 'i'}

>>>

s.remove(x):从集合s中移除数据项x,如果不存在，则报KeyError异常：

>>> s

{'d', 'a', 'r', 'c', 'i'}

>>> s.remove("s")

Traceback (most recent call last):

File "", line 1, in

s.remove("s")

KeyError: 's'

>>>

s.intersection(t):返回s和t的交集集合，等同于s&t：

>>> s = set("basketball")

>>> t = set("football")

>>> s2 = s.intersection(t)

>>> s2

{'b', 'l', 'a', 't'}

>>>

s.intersection_update(t):不返回新的集合，使s变为s和t的交集，等同于s&=t:

>>> s = set("basketball")

>>> t = set("football")

>>> s&=t

>>> s

{'b', 'l', 'a', 't'}

>>>

s.isdisjoint(t):如果集合s和t中没有相同的项，就返回true：

>>> s.isdisjoint(t)

False

>>>

s.issubset(t):如果s等于t或者s是t的子集，则返回True，等同于s<=t:

>>> s = set("number")

>>> t = set("bignumber")

>>>

>>> s.issubset(t)

True

>>>

s.issuperset(t):如果s等于t或者s是t的超集，则返回True，等同于s>=t:

>>> s = set("number")

>>> t = set("bignumber")

>>> s.issuperset(t)

False

>>> t.issuperset(s)

True

>>>

s.pop():返回并移除s中的一个随机项，如果s为空集，则报KeyError异常：

>>> s

{'n', 'r', 'b', 'u', 'm', 'e'}

>>> s.pop()

'n'

>>>

s.symmetric_difference(t):返回一个新集合，包含s和t的对称差集，即s和t的交集以外的元素，等同于s ^ t:

>>> s = set("number")

>>> t = set("big number")

>>> s.symmetric_difference(t)

{' ', 'g', 'i'}

>>>

s.symmetric_difference_update(t):不返回一个新集合，使集合s包含s和t的对称差集，即s和t的交集以外的元素，等同于s ^= t:

>>> s.symmetric_difference_update(t)

>>> s

{' ', 'g', 'i'}

>>>

s.union(t):返回一个新集合，为s和t的并集，等同于s | t:

>>> s.union(t)

{' ', 'n', 'r', 'g', 'b', 'u', 'm', 'e', 'i'}

>>>

s.update(t):将s变为s和t的并集，等同于s |= t:

>>> s.update(t)

>>> s

{' ', 'n', 'r', 'g', 'b', 'u', 'm', 'e', 'i'}

>>>

2.3.set的常用场景

1.可以用来删除重复的项，如：

>>> l = list("10101001")

>>> l

['1', '0', '1', '0', '1', '0', '0', '1']

>>> l= list(set("10101001"))

>>> l

['1', '0']

>>>

2.通过将数据存放到set中可以确保没有重复的数据：

>>> s = set()

>>> s.add("basketball")

>>> s.add("football")

>>> s.add("football")

>>> s

{'football', 'basketball'}

>>>

这种形式常用于for循环中进行遍历时：  for item in set(items)

3.用于删除不需要的数据：

>>> filenames = {"test.txt","001.log","show.bak"}

>>> for fn in filenames:

if fn.endswith(".txt"):

filenames.discard(fn)

# 出现异常

Traceback (most recent call last):

File "", line 1, in

for fn in filenames:

RuntimeError: Set changed size during iteration

这里出现RuntimeError异常，说明不能使用原来的filenames集合，因此通过set(fileenames)得到一个浅拷贝进行操作:

>>> for fn in set(filenames):

if fn.endswith(".txt"):

filenames.discard(fn)

>>> filenames

{'001.log', 'show.bak'}

>>>

也可用通过集合操作符进行操作如：

>>> filenames = {"test.txt","001.log","show.bak"}

>>> filenames = set(filenames)-{"test.txt"}

>>> filenames

{'show.bak', '001.log'}

>>>

2.4.集合内涵

和列表内涵类似，当集合数据项太长时，可以使用集合内涵类创建集合，集合内涵是一个循环表达式，格式如下  S = {expression for item in iterable if condition}  比如要创建一个0-100的偶数集合：

>>> s = {num for num in range(0,100) if num%2 == 0}

>>> s

{0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98}

>>>

集合内涵中的iterable也可以是一个集合内涵。

3.固定集合frozenset类型

frozenset类型集合是指创建之后就不能改变的集合。

3.1.frozenset集合的创建

1.使用frozenset()进行创建，不给定参数时将返回一个空的固定集合：

>>> fs = frozenset()

>>> fs

frozenset()

>>>

2.带一个frozenset参数时，将返回该参数的浅拷贝：

>>> frozenset(fs)

frozenset()

>>>

3.传入其他参数时，将规定的对象转换为frozenset：

>>> fs = frozenset("frozenset")

>>> fs

frozenset({'o', 'n', 's', 'r', 't', 'f', 'z', 'e'})

>>>

3.2.常用操作符和方法：

固定集合是不变的，因此其支持的方法和操作符不能影响固定集合本身,故对于set集合中不改变本身的方法和操作符都是支持的。  fs.copy():返回fs的浅拷贝

>>> fs2 = frozenset("frozenset")

>>> fs = fs2.copy()

>>> fs

frozenset({'o', 'n', 's', 'r', 't', 'f', 'z', 'e'})

>>>

fs.difference(t):返回一个新的固定集合，包含在fs中且不在t中的数据项，等同于fs - t：

>>> fs1 = frozenset("frozenset")

>>> fs2 = frozenset("set")

>>> fs1.difference(fs2)

frozenset({'o', 'n', 'r', 'f', 'z'})

>>>

>>> fs - fs2

frozenset({'o', 'n', 'r', 'f', 'z'})

>>>

fs.intersection(t):返回一个新集合，fs和t的交集，等同于fs1 & t：

>>> fs1 = frozenset("frozenset")

>>> fs2 = frozenset("set")

>>> fs1.intersection(fs2)

frozenset({'s', 'e', 't'})

>>>

>>> fs1 & fs2

frozenset({'s', 'e', 't'})

>>>

fs.isdisjoint(t):如果fs和t没有相同数据项，返回True：

>>> fs1.isdisjoint(fs2)

False

>>>

fs.issubset(t):如果fs等于t或者fs为t的子集，则返回True，等同于fs <= t:

>>> fs2.issubset(fs1)

True

>>>

fs.issupperset(t):如果fs等于t或者fs为t的超集，则返回True，等同于fs >= t:  fs.union(t):返回一个新集合，为fs和t的并集，等同于fs | t：

>>> fs3 = frozenset("fs3")

>>> fs4 = frozenset("fs4")

>>> fs3.union(fs4)

frozenset({'3', '4', 'f', 's'})

>>>

fs.symmetric_difference(t):返回一个新集合，为fs和t的对称差集，等同于fs ^ t:

>>> fs5 = frozenset("apple")

>>> fs6 = frozenset("people")

>>> fs5.symmetric_difference(fs6)

frozenset({'o', 'a'})

>>>