python基础变量之---集合

python基础变量之—集合

---

---

一、集合

1.集合介绍

在Python中，集合（set）是一种无序的、不重复的数据结构，用于存储唯一的元素，支持数学集合的一些操作，如交集、并集、差集等。集合中的元素是无序的，即不记录元素的插入顺序，且每个元素只能出现一次，集合可以通过大括号{}或set()函数来创建，集合的元素必须是可哈希的（不可变的），例如数字、字符串、元组等，但列表、字典等可变类型不能作为集合的元素

• 集合是可变的容器，固定集合是不可变的集合
• 集合相当于只有键没有值的字典，当然你也可以理解为键和值相等
• 集合内的数据都是唯一的，不可变的

2.集合创建

创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
创建集合

#创建集合
s1=set()
print(s1)

s2={1,2,3,4,5}
print(s2)

s3={10,20,30,40,50}
print(s3)

s4={2,}
print(s4)
print(type(s4))

set()
{1, 2, 3, 4, 5}
{50, 20, 40, 10, 30}
{2}

#集合中不存在相同的元素
s5={1,2,3,4,5,1,2,3,4,5,6,7,8,9,10,11,12,1}
print(s5)

s6={(10,20),(20,10)}
print(s6)

s8={(10,),(10,)}
#由于id不同，在其他编程语言一个输出为{(10,),(10,)}
#在python中为特例，认为他们是相同的，所以输出{(10,)}
print(s8)

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
{(20, 10), (10, 20)}
{(10,)}

#固定集合
s9=frozenset({1,2,3,4,5,6,7,8,9,10,1})
print(s9)
#固定集合后不可以修改

frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9, 10})

3.集合操作

添加元素

s1=set([1,2,3,4,5])
s1.add(6)
s1.add(1)
print(s1)

s1.update([7,8,9])#添加多个数据
print(s1)
s1.update([1,2,3,4,5],(10,20))#添加多个数据
print(s1)

{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20}

删除数据

s1={1,2,3,4,5}
s1.remove(1)
#s1.remove(1)#不存在时报错
print(s1)
s1.discard(1)#不存在不报错

s1.pop()#进行无序的排序，然后删除
print(s1)#可以看做一直取

{2, 3, 4, 5}
{3, 4, 5}

in/not in

s1 = {10, 20, 30}
print(20 in s1)

True

4.集合常见API

添加元素

s1 = {1,2,3,4,5,6,7,8,9}
s1.add(11)#添加元素
print(s1)

{1, 2, 3, 4, 5, 6, 7, 8, 9, 11}

清空集合

s1 = {1,2,3,4,5,6,7,8,9}
s1.clear()#清空集合
print(s1)

set()

复制集合

s1 = {1,2,3,4,5,6,7,8,9}
s2=s1.copy()
print(s2)#复制集合

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

返回两个集合的差集

s1 = {1,2,3,4,5,6,7,8,9}
s2 ={8,9,13}
s3=s1.difference(s2)#返回两个集合的差集
print(s3)

{1, 2, 3, 4, 5, 6, 7}

差集并更新

s1 = {1,2,3,4,5,6,7,8,9}
s2 ={8,9,13}
s3=s1.difference_update(s2)#差集并更新
print(s3)

None

交集

#iou yolo的一个算法
s1 = {1,2,3,4,5,6,7,8,9}
s2 ={8,9,13}
s3=s1.intersection(s2)#交集
print(s3)

{8, 9}

并集

s1 = {1,2,3,4,5,6,7,8,9}
s2 ={8,9,13}
s3=s1.union(s2)#并集
print(s3)

{1, 2, 3, 4, 5, 6, 7, 8, 9, 13}

判断两个集合是否是独立的

s1 = {1,2,3}
s2 ={8,9,13}
s3=s1.isdisjoint(s2)#判断两个集合是否是独立的
print(s3)

True

判断s1是否是s2的超集

s1 = {1,2,3,4,5,6,7,8,9}
s2 ={8,9}
s3=s1.issuperset(s2)#判断s1是否是s2的超集
print(s3)

True

判断s1是否是s2的子集

s1 = {1,2,3,4,5,6,7,8,9}
s2 ={8,9,13}
s3=s1.issubset(s2)#判断s1是否是s2的子集
print(s3)

False

返回两个不重复的集合

#f返回两个不重复的集合
s1 = {1,2,3,4,5,6,7,8,9}
s2 ={8,9,13}
s3=s1.symmetric_difference(s2)#返回两个集合的差集变成一个新的
print(s3)

{1, 2, 3, 4, 5, 6, 7, 13}

返回两个集合的差集保存到s1

s1 = {1,2,3,4,5,6,7,8,9}
s2 ={8,9,13}
s3=s1.symmetric_difference_update(s2)#返回两个集合的差集保存到s1
print(s3)

print(type(None))

None

二，可变与不可变类型

1.可变

1.列表：列表是可变的，可以在原地修改其元素、添加或删除元素。

x = [1, 2, 3, 4]
x[1] = 5
print(x)

2.字典：字典也是可变类型，可以修改其键值对。

dict1 = {'name':'张三','age':18,'sex':'男'}
dict2 = {'name':'李四','age':16,}
dict1.update(dict2)#更新字典
print(dict1)

3.集合：集合是可变的，可以添加或删除元素。

s1 = {1,2,3,4,5,6,7,8,9}
s1.add(11)#添加元素
print(s1)

自定义对象：自定义类的实例如果没有在类中明确限制其属性，可以修改实例的属性值，因此对象实例也是可变的。

2.不可变

其主要核心思想是被输入的数据被底层二进制所录存，其其他增删查改行为不会改变底层二进制。

• 1.数值类型：数字的值一旦赋值，不能被修改。
• 2.字符串：字符串是不可变的，任何试图修改字符串内容的操作都会生成一个新的字符串
• 3.元组：元组是不可变的容器类型，一旦创建，其内容不能更改。
• 4.冻结集合：frozenset 是不可变版本的集合，一旦创建，无法修改其元素。
• 5.布尔值：布尔值 True 和 False 也属于不可变类型。
• 6.字节串和None也是不可变类型

3.二者区别

1. 内存管理

   • 对不可变类型改值时，Python会创建一个新的对象，并将该对象的引用赋给原来的变量。
   • 对可变类型修改内容时，不会创建新的对象，而是直接在原地进行修改。

2. 行为差异

   • 不可变对象的引用在修改后总会指向一个新对象，而可变对象的引用在修改时仍然指向原始对象。

3. 作为字典键

   • 不可变类型具有固定的哈希值，可以作为字典的键。
   • 可变类型哈希值可能变化，不能作为字典的键。

三，类型转换

函数	说明	示例
int(x)	将 x 转换为整数类型。	int("10") → 10
float(x)	将 x 转换为浮点数类型。	float("3.14") → 3.14
str(x)	将 x 转换为字符串类型。	str(123) → "123"
list(x)	将 x 转换为列表类型，x 必须是可迭代对象。	list((1, 2, 3)) → [1, 2, 3]
tuple(x)	将 x 转换为元组类型，x 必须是可迭代对象。	tuple([1, 2, 3]) → (1, 2, 3)
set(x)	将 x 转换为集合类型，x 必须是可迭代对象。	set([1, 2, 3]) → {1, 2, 3}
dict(x)	将 x 转换为字典类型，x 必须是可迭代的键值对序列（如列表、元组）。	dict([('a', 1), ('b', 2)]) → {'a': 1, 'b': 2}
bool(x)	将 x 转换为布尔类型，x 的值可以是任何对象，返回 True 或 False。	bool(0) → False ； bool("abc") → True
frozenset(x)	将 x 转换为冻结集合，x 必须是可迭代对象。	frozenset([1, 2, 3]) → frozenset({1, 2, 3})
bytes(x)	将 x 转换为字节串类型，x 可以是字符串、字节数组等。	bytes("hello", "utf-8") → b'hello'
complex(x)	将 x 转换为复数类型。	complex(2) → (2+0j)
chr(x)	将整数 x 转换为对应的字符，x 是 Unicode 码点。	chr(97) → 'a'
ord(x)	将字符 x 转换为对应的整数，x 是一个单一字符。	ord('a') → 97
eval(x)	将字符串 x 作为 Python 表达式进行求值并返回结果。	eval('3 + 4') → 7
set(x)	将可迭代对象 x 转换为集合。	set([1, 2, 2, 3]) → {1, 2, 3}