本文共 4406 字，大约阅读时间需要 14 分钟。

Python基础变量之—集合

一、集合

1. 集合介绍

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

• 集合是可变的容器，固定集合是不可变的集合。
• 集合相当于只有键没有值的字典，键和值相等。
• 集合内的数据都是唯一的，不可变的。

2. 集合创建

创建一个空集合必须用 set() 而不是 {}，因为 {} 是用来创建一个空字典。以下是集合的创建示例：

# 创建集合 s1
s1 = set()
print(s1)  # 输出: set()
s2 = {1, 2, 3, 4, 5}
print(s2)  # 输出: {1, 2, 3, 4, 5}
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,)}
# 在其他编程语言中，输出 {(10,), (10,)}，但在 Python 中由于 id 不同，会被认为是相同的元素，所以输出 {(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})
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)  # 删除元素
# print(s1)  # 如果元素不存在会报错
s1.discard(1)  # 如果元素不存在不会报错
print(s1)
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

交集

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)
print(s3)

True

判断s1是否是s2的子集

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

False

返回两个不重复的集合

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)
print(s3)
print(type(None))

None

二，可变与不可变类型

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)

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

2. 不可变

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

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

3. 二者区别

5. 内存管理

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

6. 行为差异

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

7. 作为字典键

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

三，类型转换

以下是 Python 中常用的类型转换函数及其示例：

函数	说明	示例
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}

通过这些类型转换函数，可以将不同类型的数据进行转换和操作，从而在实际开发中灵活运用。

转载地址：http://yoofk.baihongyu.com/