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 "<pyshell#633>", line 1, in <module>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 "<pyshell#762>", line 1, in <module>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 "<pyshell#885>", line 1, in <module>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'})
>>>

[Python] Python数据类型(三）集合类型之set集合和frozenset集合相关推荐

python中的集合set类型是可变的吗_[Python] Python数据类型(三）集合类型之set集合和frozenset集合...
1.集合基本概念集合是0-n个对象引用的无序组合,集合中存储的元素不可重复,因此这些对象引用的引用的对象必须是可哈希运算的 . 1.python中提供了两种内置的集合类型:可变的set类型和固定的 ...
7.Set集合总结（TreeSet集合和HashSet集合）
一.Set集合 1.Set集合特点可以去除重复存取顺序不一致没有带索引的方法,所以不能使用普通的for循环遍历,也不能通过索引来获取.删除Set集合里面的元素. 2.Set集合中元素的遍历二. ...
1-17 Set集合和Map集合
Hash表 Hash,一般翻译做"散列",也有直接音译为"哈希"的,它是基于快速存取的角度设计的,也是一种典型的**"空间换时间"**的做法 ...
Day_8/08(List集合和Set集合)
目录一.List集合 1.ArrayList集合 2.LinkedList集合 1.增加元素 2.查询元素 3.修改元素 4.删除元素二.Set集合 1.HashSet集合 2.LinkedHas ...
scala集合和java集合的转换-List
scala集合和java集合的转换-List scala的List要想转换成java的list 需要导入对应的类scala.collection.JavaConverters._ import jav ...
Map集合和List集合总结
Map集合和List集合哪个效率更高 List接口 List集合是一个元素有序(存储有序).可重复的集合,集合中的每个元素都有对应的索引,以便于查询和修改,List集合是允许存储null值的. Lis ...
python三种数据类型_Python零基础入门学习02：Python基本数据类型：数字类型
注 :本文所有代码均经过Python 3.7实际运行检验,保证其严谨性. Python学习 Python有三种不同的数字类型:整数(int),浮点数(float)和复数(complex). 值得注意的 ...
Python数据类型(三)数据结构类型—list、tuple、range、set、frozenset、dict
数据结构类型是指用来存储数据.文字.字符.二进制.类对象,进一步方便操作查找存储内容的结构.数据类型分为了序列类型.集合类型.映射类型. 序列类型是Python数据类型的内置基本数据类型,有三种 ...
Python组合数据类型：容器类型总览，(不)可变数据类型immutable、(不)可迭代对象iterable、迭代器iterator、生成器generator、语法糖
一.组合数据类型container objects 组合数据类型container objects:能够表示多个数据的类型集合类型:集合类型是一个元素集合,元素无序不重不变序列类型:序列类型是一个 ...

[Python] Python数据类型(三）集合类型之set集合和frozenset集合