Python基础之集合和变量类型（四）

Python基础之集合和变量类型（四）

---

一、集合

1.1 创建集合

• 直接创建（集合中不能存在同样的数据）

s = set()
print(s) #set()
s = set("ABCD")
print(s) #{'D', 'B', 'C', 'A'}

# 集合中保存的数据不能存在相同的数据
s = set(range(10))
print(s) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

s = set("ABABBBBCCC")
print(s) # {'A', 'B', 'C'}

s = set((1,2,3,4,0,2,2,2,4,4))
print(s) # {0, 1, 2, 3, 4}

s = set([1,2,3,4,5,6,1,1,1,5,5])
print(s) # {1, 2, 3, 4, 5, 6}

• 固定集合frozenset（不可修改）

s = frozenset([1,2,3,4,5,6,1,1,1,5,5])
print(s) # frozenset({1, 2, 3, 4, 5, 6})

1.2 集合操作

1.2.1添加数据

• 添加集合add和update函数
  • add函数，添加一个数据
  • update函数，添加元素到集合，且参数可以是列表、元组、字典等，x 可以有多个，用逗号分开。

s1 = set((4, 5, 6, 7))
s1.add(100) #
print(s1) # {4, 5, 6, 7, 100}
s1.update([200,300]) #
print(s1) # {4, 5, 6, 7, 100, 200, 300}

1.2.2 删除数据

• 能删单一的元素也能清空字典，显式删除一个字典用del命令

# 删除元素
s = {1,2,3,4,5}
s.remove(1)
print(s) # {2, 3, 4, 5}
s.discard(3)
s.discard(10000) # discard函数删除数据超出范围时不会报无异常,而remove函数删除数据超出范围时会报异常
print(s)

s1 = {10,1,3,4,5}
s1.pop()
print(s1) #{3, 4, 5, 10}   删除1，先排序再删

s2 = {"daming","san","xiaoming","a1","b3"}
re = s2.pop()
print(s2,re) #{'a1', 'b3', 'xiaoming', 'daming'} san

1.3 常见API

官方文档：https://docs.python.org/zh-cn/3.13/library/stdtypes.html#mapping-types-dict
链接: link

• 操作字典的函数：

序号	函数	描述
1	len(dict)	计算字典元素个数，即键的总数。
2	str(dict)	输出字典，可以打印的字符串表示。
3	type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

• 字典的方法：

序号	函数及描述
1	dict.clear()删除字典内所有元素
2	dict.copy()返回一个字典的浅复制
4	dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict如果键在字典dict里返回true，否则返回false
6	dict.items()以列表返回一个视图对象
7	dict.keys()返回一个视图对象
9	dict.update(dict2)把字典dict2的键/值对更新到dict里
10	dict.values()返回一个视图对象
11	pop(key,default)删除字典 key（键）所对应的值，返回被删除的值。

• 示例

s1 = {10,1,3,4,5}
s2 = {1,2,3,4,5,6,7,8,9}
s3 = s1.difference(s2) # 差集
print(s3) # {10}

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

s5 = s1.intersection(s2) # 交集
print(s5) # {1, 3, 4, 5}

s5 = s1.isdisjoint(s2) # 判断两个集合是否有相同的元素，有就返回False，没有就返回True
print(s5) # False

s6 = s1.issubset(s2) # 判断s1是否是s2的子集，是就返回True，不是就返回False
print(s6) # False

s7 = s1.symmetric_difference(s2) #两个集合中不相同的元素，并集减交集
print(s7) # {2, 6, 7, 8, 9, 10}

二、变量类型

2.1 可变与不可变

2.1.1 不可变类型

不可变类型的值一旦创建，就无法改变。任何试图修改不可变对象的操作都会创建一个新的对象。常见不可变类型包括：

1. 数值类型：int、float、complex

   数字的值一旦赋值，不能被修改。

2. 字符串：str

   字符串是不可变的，任何试图修改字符串内容的操作都会生成一个新的字符串。

3. 元组：temple

   元组是不可变的容器类型，一旦创建，其内容不能更改。

4. 冻结集合：frozenset

   frozenset 是不可变版本的集合，一旦创建，无法修改其元素。

5. 布尔值：bool

   布尔值 True 和 False 也属于不可变类型。

6. 字节串和None

   字节串和None为不可变类型。

• 示例

x=10
print("x_id",id(x))
x=x+30
print("x_id",id(x))
print(x)#x变量变了 变成了40 但是 x最开始保存的数字10  是没变的

str1="hello world"
str1=str1.upper()
print(str1)

t1=(10,20)
# del t1[0]

l1=[10,20]
print(l1)
print(id(l1))
# l1=[20]#l1变量变了 变成 了一个新列表 不能证明列表是可以变的
l1[1]=666#l1变量没有变 但是l1变量保存的数据容器内部的数据 已经变了
print(l1)
print(id(l1))

2.1.2 可变类型

可变类型的值在创建后可以被修改。常见的可变类型：

1. 列表：list

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

2. 字典：dict

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

3. 集合：set

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

4. 自定义对象

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

2.1.3 二者区别

1. 内存管理

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

2. 行为差异

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

3. 作为字典键

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

2.2 类型判断

• 使用isinstance函数进行判断
• 示例

x=10
re=isinstance(x,int)
print(re) # True

print(isinstance(10,int)) # True
print(isinstance(3.14,float)) # True
print(isinstance(3.14+10j,complex)) # True
print(isinstance("3.14",str)) # True
print(isinstance((10,20),(int,str))) # False
print(isinstance(True,(int,str,bool))) # True
print(isinstance((10,20),tuple)) # True
print(type(None)) # 

2.3 类型转换

以下是将右边的例子全部换掉后的表格：

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

• 例子

x=10
x={"name":"jack","age":20}
x=(10,20)
re=str(x)
print(re,type(re))


# unicode转字符
x=69 #65 97 37 113
re=chr(x)
print(re) #E

x="q"
re=ord(x)
print(re) #113

l2=["10","2","32","3","2","3","2","3","2"]
str3="+".join(l2)
print(str3)
total=eval(str3)
print(total) #59