python集合

最新推荐文章于 2022-09-30 17:48:12 发布

要去找佳佳

最新推荐文章于 2022-09-30 17:48:12 发布

阅读量227

点赞数

文章标签： python

本文链接：https://blog.csdn.net/m0_47152016/article/details/122054284

版权

1.集合与字典的关系

>>> type({})
<class 'dict'>
>>> type({"F"})
<class 'set'>
>>> type({"F":'f'})
<class 'dict'>

2.创建一个集合

"""方法一：使用花括号"""

>>> {"FishC", "Python"}
{'Python', 'FishC'}

"""方法二：集合推导式"""

>>> {s for s in "FishC"}
{'h', 'C', 'i', 'F', 's'}
#这里可以看出集合的无序性

"""方法三：使用类型构造器、set（）"""

>>> set("FishC")
{'h', 'C', 'i', 'F', 's'}

3.访问

"""由于集合是无序的，故不能使用下标进行访问"""

>>> s = set("FishC")
>>> s[0]
Traceback (most recent call last):
  File "<pyshell#130>", line 1, in <module>
    s[0]
TypeError: 'set' object is not subscriptable

"""使用in 和not in"""

>>> 'C' in s
True
>>> 'c' not in s
True

"""使用迭代"""

>>> for each in s:
	print(each)

	
h
C
i
F
s

4.集合的特点

"""集合的特点一、无序性"""



"""集合的特点二、唯一性"""


"""利用集合实现去重的操作："""
>>> set([1, 1, 2, 3, 5])
{1, 2, 3, 5}

"""注意使用列表推导式会出现问题"""
>>> nums = [1, 2, 3, 1]
>>> t = []
>>> [i for i in nums if i not in t]
[1, 2, 3, 1]

"""使用循环"""
>>> nums = [1, 2, 3, 1]
>>> t = []
>>> for i in nums:
	if i not in t:
		t.append(i)

		
>>> t
[1, 2, 3]


"""检测一个列表中是否出现重复的元素"""
>>> s = [1, 1, 2, 3, 5]
>>> len(s) == len(set(s))
False

5.集合的方法

copy（）

"""浅拷贝"""

>>> s
[1, 1, 2, 3, 5]
>>> t = s.copy()
>>> t
[1, 1, 2, 3, 5]

isdestroyed（）

"""disjoint    v. 打散；拆开；（使）关节脱离
                adj. 不连贯的；（两个集合）不相交的"""

"""isdisjoint（）判断两个集合是否毫不相干"""
>>> s = set("FishC")
>>> s.isdisjoint(set("Python"))
False
#这里交集是'h'
>>> s.isdisjoint(set("JAVA"))
True

"""isdisjoint(iterable)，这里传入一个可迭代对象即可，不一定要是集合"""

>>> s.isdisjoint("JAVA")
True
>>> s.isdisjoint("Python")
False

issubset（）

"""subset    n. [数] 子集；子设备；小团体"""

"""检测一个集合是否是另一个集合的子集"""

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s.issubset("FishC.com.cn")
True

issuperset（）

"""superset    n. 超集"""

"""检测一个集合是否是另一个集合的超集"""

"""如果一个集合S2中的每一个元素都在集合S1中，且集合S1中可能包含S2中没有的元素，则集合S1就是S2的一个超集，反过来，S2是S1的子集。 S1是S2的超集，若S1中一定有S2中没有的元素，则S1是S2的真超集，反过来S2是S1的真子集。"""

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s.issuperset("Fish")
True

union（）

"""union    n.    并集；联合；联邦；结合"""

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s.union({1, 2, 3})
{'h', 'C', 1, 's', 'i', 2, 3, 'F'}

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s.union({1, 2, 3}, "FishC")
{'h', 'C', 1, 's', 'i', 2, 3, 'F'}

"""union（）支持多参数"""

intersection（）

"""intersection    n. 交集；十字路口；交叉点；交点"""

>>> s.intersection("Fish")
{'h', 's', 'i', 'F'}

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s.intersection("php", "Python")
{'h'}

"""intersection（）支持多参数"""

difference（）

"""difference    n. 差集；差异，不同之处；差额；分歧"""

"""一般地，记A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A减集合B(或集合A与集合B之差)，类似地，对于集合A、B，我们把集合{x∣x∈A,且x∉B}叫做A与B的差集"""

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s.difference("Fish")
{'C'}

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s.difference("php", "Python")
{'C', 's', 'i', 'F'}

"""difference（）支持多参数"""

symmetric_difference（）

"""symetric   adj. 对称的"""

"""对称差集：对于两个集合A，B，先排除集合A和集合B的所有共同元素，由剩余的元素组成的集合，叫做集合A与集合B的对称差集"""

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s.symmetric_difference("Python")
{'s', 'P', 'n', 't', 'C', 'i', 'o', 'F', 'y'}


"""symmetric_difference（）不支持多参数"""

6.集合运算符

"""    <=    检测子集"""

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s <= set("FishC")
True

>>> s <= "FishC"
Traceback (most recent call last):
  File "<pyshell#169>", line 1, in <module>
    s <= "FishC"
TypeError: '<=' not supported between instances of 'set' and 'str'

"""注意：必须传入集合，不能传入字符串"""

"""    <    检测真子集"""

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s < set("FishC.com.cn")
True

>、>= 检测真超集和超集

| 并集

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s | {1, 2, 3} | set("Python")
{'h', 1, 2, 3, 'P', 'n', 'C', 't', 'i', 'F', 'o', 's', 'y'}

& 交集

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s & set("Php") & set("Python")
{'h'}

- 差集

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s - set("Python") - set("Php")
{'C', 'i', 'F', 's'}

^ 对称差集

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s ^ set("Python")
{'P', 't', 'i', 's', 'n', 'C', 'o', 'F', 'y'}

WARNING！！使用方法传入可迭代对象、使用运算符两边必须是集合！！！

以上内容不会修改集合、适用于set和frozenset

以下内容会修改集合、不适用于frozenset

7.集合的分类

可变集合——set（）；不可变集合——frozenset（）

>>> t = frozenset("FishC")
>>> t
frozenset({'h', 'C', 'i', 'F', 's'})

8.只适用于set的方法：

update（*others）即是 union update

"""使用others参数指定的值更新集合"""

"""other表示只支持一个参数；others表示支持多个参数"""

s
{'h', 'C', 'i', 'F', 's'}
>>> s.update([1, 2], "23")
>>> s
{'h', 1, 2, 'C', '3', 'i', 'F', '2', 's'}
#注意这里传入的字符串迭代获取其中每一个字符作为元素插入带集合中
"""这里传进去两个可迭代对象，其满足唯一性的每一个元素都被插入到集合s中"""

>>> t
frozenset({'h', 'C', 'i', 'F', 's'})
>>> t.update([1, 1], "23")
Traceback (most recent call last):
  File "<pyshell#188>", line 1, in <module>
    t.update([1, 1], "23")
AttributeError: 'frozenset' object has no attribute 'update'

intersection_update（*others）、difference_update（*others）、symmetric_difference——update（others）

"""
intersection_update（）        使用交集的方式更新集合
difference_update（）          使用差集的方式更新集合
symmetric_difference_update()  使用对称差集的方式更新集合
"""

>>> s
{'h', 1, 2, 'C', '3', 'i', 'F', '2', 's'}
>>> s.intersection_update("FishC")
>>> s
{'h', 'C', 'i', 'F', 's'}

>>> s
{'h', 'C', 'i', 'F', 's'}
>>> s.difference_update("Php", "python")
>>> s
{'C', 'i', 'F', 's'}

>>> s
{'C', 'i', 'F', 's'}
>>> s.symmetric_difference_update("Python")
>>> s
{'h', 'P', 'n', 'C', 't', 'i', 'F', 'o', 's', 'y'}

add（elem）

>>> s
{'h', 'P', 'n', 'C', 't', 'i', 'F', 'o', 's', 'y'}
>>> s.add("45")
>>> s
{'h', 'P', 'n', 'C', 't', 'i', 'F', 'o', 's', 'y', '45'}

"""注意这里的‘45‘作为一个元素插入到s中，而不是插入'4'和'5'"""

remove（elem）、discard（elem）

"""
discard    v. 扔掉，弃置；

remove（）和discard（）的区别是：
如果没有这个元素，remove（）会抛出异常，而discard（）会静默处理
"""

>>> s
{'h', 'P', 'n', 'C', 't', 'i', 'F', 'o', 's', 'y', '45'}
>>> s.remove("瓦迈")
Traceback (most recent call last):
  File "<pyshell#199>", line 1, in <module>
    s.remove("瓦迈")
KeyError: '瓦迈'

>>> s.discard("瓦迈")
>>> s
{'h', 'P', 'n', 'C', 't', 'i', 'F', 'o', 's', 'y', '45'}

pop（）

"""随机从集合中弹出一个元素（集合中的元素是无序的）"""

>>> s
{'h', 'P', 'n', 'C', 't', 'i', 'F', 'o', 's', 'y', '45'}
>>> s.pop()
'h'
>>> s.pop()
'P'
>>> s.pop()
'n'

clear（）

"""清空集合"""

>>> s
{'C', 't', 'i', 'F', 'o', 's', 'y', '45'}
>>> s.clear()
>>> s
set()

9.可哈希

— 想要正确的创建集合和字典，其刚性需求为字典的键、集合的元素都必须是可哈希的

— 如果一个对象是可哈希的，那么其在整个程序的生命周期中必须保持不变

— python中，大多数不可变对象都是可哈希的，而可变对象都是不可哈希的

hash（object）

"""通过hash（object）获取一个对象的哈希值"""

>>> hash(1)
1
>>> hash(1.0)
1
>>> hash(1.001)
2305843009213441

"""从中可以看出：如果我们对一个整数进行哈希，求得的哈希值永远都等于其本身；
    如果两个对象的值相等，则其哈希值一定相等"""

>>> hash("FishC")
-4635247203901248307
>>> hash([1, 2, 3])

Traceback (most recent call last):
  File "<pyshell#212>", line 1, in <module>
    hash([1, 2, 3])
TypeError: unhashable type: 'list'

>>> hash((1, 2, 3))
529344067295497451

"""元组，字符串是不可变对象，是可哈希的，
而列表是可变对象，不可哈希，不能作为dict的键和set的elem"""

>>> {[1, 2, 3]:"FishC"}
Traceback (most recent call last):
  File "<pyshell#214>", line 1, in <module>
    {[1, 2, 3]:"FishC"}
TypeError: unhashable type: 'list'

>>> {"Python", [1, 2, 3]}
Traceback (most recent call last):
  File "<pyshell#215>", line 1, in <module>
    {"Python", [1, 2, 3]}
TypeError: unhashable type: 'list'

"""+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"""

"""set不可嵌套，因为set是可变的容器，是不可哈希的"""

>>> x = {1, 2, 3}
>>> y = {x, 4, 5}
Traceback (most recent call last):
  File "<pyshell#217>", line 1, in <module>
    y = {x, 4, 5}
TypeError: unhashable type: 'set'

"""解决方法：使用frozenset："""

>>> x = frozenset({1, 2, 3})
>>> y = {x, 4, 5}
>>> y
{frozenset({1, 2, 3}), 4, 5}

要去找佳佳

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python集合

1.集合与字典的关系>>> type({})<class 'dict'>>>> type({"F"})<class 'set'>>>> type({"F":'f'})<class 'dict'>2.创建一个集合"""方法一：使用花括号""">>> {"FishC", "Python"}{'Python', 'FishC'}"""方法二：集合推导式"""&gt
复制链接

扫一扫