Python学习笔记8——数据类型（下）

---

一、集合（set）

集合是一个 无序 、可变、不允许数据重复的容器。

1.1 定义

v1 = { 11, 22, 33, "alex" }

• 无序，无法通过索引取值。
• 可变，可以添加和删除元素。

v1 = {11,22,33,44}
v1.add(55)
print(v1) # {11,22,33,44,55}

• 不允许数据重复。

v1 = {11,22,33,44}
v1.add(22)
print(v1) # {11,22,33,44}

集合的使用场景

当维护一大堆不重复的数据时，就可以用它。比如：做爬虫去网上找图片的链接，为了避免链接重复，可以选择用集合去存储链接地址。

注意：定义空集合时，只能使用v = set()，不能使用 v={}（这样是定义一个空字典）。

v1 = []
v11 = list()

v2 = ()
v22 = tuple()

v3 = set()

v4 = {} # 空字典
v44 = dict()

1.2 集合独有功能

1.2.1 Python Set add()方法

描述
add() 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

语法
add()方法语法：

set.add(element)

参数

• element – 必需，要添加的元素。

返回值
无。

代码示例

data = {"刘嘉玲", '关之琳', "王祖贤"}
data.add("郑裕玲") # {"刘嘉玲", '关之琳', "王祖贤","郑裕玲"}
print(data)

data = set()
data.add("周杰伦")
data.add("林俊杰")
print(data) #{"周杰伦"、"林俊杰"} 

1.2.2 Python Set discard() 方法

描述
discard() 方法用于移除指定的集合元素。

该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

语法
discard() 方法语法：

set.discard(value)

参数

• value – 必需，要移除的元素

返回值
无。

代码示例

data = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
data.discard("关之琳") 
print(data)

1.2.3 Python Set remove() 方法

描述
remove() 方法用于移除集合中的指定元素。

该方法不同于 discard() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

语法
remove() 方法语法：

set.remove(item)

参数

• item – 要移除的元素。

返回值
无。

代码示例

fruits = {"apple", "banana", "cherry"}
 
fruits.remove("banana") 
 
print(fruits) #{'cherry', 'apple'}

1.2.4 Python Set pop() 方法

描述
pop() 方法用于随机移除一个元素。

语法
pop() 方法语法：

set.pop()

参数
无。

返回值
返回移除的元素。

fruits = {"apple", "banana", "cherry"}
 
x = fruits.pop() # 注意这是随机移除元素
 
print(fruits) #{"apple", "cherry"}
print(x) #banana

1.2.5 Python Set intersection() 方法

描述
intersection() 方法用于返回两个或更多集合中都包含的元素，即交集。

语法
intersection() 方法语法：

set.intersection(set1, set2 ... etc)

参数

• set1 – 必需，要查找相同元素的集合。
• set2 – 可选，其他要查找相同元素的集合，可以多个，多个使用逗号隔开。

返回值
返回一个新的集合。

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}

s4 = s1.intersection(s2) # 取两个集合的交集 
print(s4) # {"⽪⻓⼭"}

#使用 & 运算符更加方便
s3 = s1 & s2   			  # 取两个集合的交集
print(s3)

1.2.6 Python Set union() 方法

描述
union() 方法返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。

语法
union() 方法语法：

set.union(set1, set2...)

参数

• set1 – 必需，合并的目标集合
• set2 – 可选，其他要合并的集合，可以多个，多个使用逗号隔开。

返回值
返回一个新集合。

代码示例

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s4 = s1.union(s2) 		# 取两个集合的并集  {"刘能", "赵四", "⽪⻓⼭","刘科⻓", "冯乡⻓", }
print(s4)

#使用 | 运算符更便捷
s3 = s1 | s2   			# 取两个集合的并集
print(s3)

1.2.7 Python Set difference() 方法

描述
difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。

语法
difference() 方法语法：

set.difference(set1)

参数

• set1 – 必需，用于计算差集的集合

返回值
返回一个新的集合。

代码示例

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s4 = s1.difference(s2) 		# 差集，s1中有且s2中没有的值 {"刘能", "赵四"}
s6 = s2.difference(s1)   	# 差集，s2中有且s1中没有的值 {"刘科⻓", "冯乡⻓"}

#使用 - 运算符更加便捷
s3 = s1 - s2   			   # 差集，s1中有且s2中没有的值
s5 = s2 - s1   			   # 差集，s2中有且s1中没有的值

print(s5,s6)

此外，同样可以使用len()函数获取集合的大小，在此不再赘述。

1.3 转换

其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除，这种方式常用于对数据进行去重操作，int/list/tuple/dict都可以转换为集合。

v1 = "武沛齐"
v2 = set(v1)
print(v2) # {"武","沛","齐"}

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}

v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}

下面是一个对data列表元素进行去重的示例。

data = [11,22,33,3,99,99]

v1 = set(data) #{11,22,33,3,99}

data = list(v1) #[11,22,33,3,99]

1.4 其他

集合的元素在存储时，首先会被解释器进行哈希hash()处理，因此集合的元素必须是可哈希的。

目前可哈希的数据类型：int、bool、str、tuple，而list、set、dict是不可哈希的。
**总结：集合的元素只能是 int、bool、str、tuple 。
注意，如果元组的子元素数据结构是不可哈希的，那么整个元组也是不可哈希的！

#转换成功
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}

#转换失败
v1 = [11,22,["alex","eric"],33]
v2 = set(v1) # 报错 
print(v2) 

因存储原理特殊，集合的查找效率非常高（数据量大了才明显）。

• 低效率

user_list = ["武沛齐","alex","李璐"]
if "alex" in user_list:
    print("在")
else:
    print("不在")
    
    
user_tuple = ("武沛齐","alex","李璐")
if "alex" in user_tuple:
    print("在")
else:
    print("不在")

• 高效率

user_set = {"武沛齐","alex","李璐"}
if "alex" in user_set:
    print("在")
else:
    print("不在")

在定义列表、集合或者字典时，可以采用多行定义法，使元素更加清晰。

data_list = [
    "alex",
    11,
    (11, 22, 33, {"alex", "eric"}, 22),
    [11, 22, 33, 22],
    {11, 22, (True, ["中国", "北京"], "沙河"), 33}
]

注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：

v1 = {True, 1}
print(v1)  # {True}

v2 = {1, True}
print(v2)  # {1}

v3 = {0, False}
print(v3)  # {0}

v4 = {False, 0}
print(v4)  # {False}

1.5 对比

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	v=[]或v=list()
tuple	否	是	无	是	tuple(其他)	v=()或v=tuple()
set	是	否	可哈希	否	set(其他)	v=set()

1.6 None类型

Python的数据类型中有一个特殊的值None，意味着这个值啥都不是 或 表示空。 相当于其他语言中 null作用一样。

在一定程度上可以帮助我们去节省内存。例如：

v1 = None
v2 = None
..
v1 = [11,22,33,44]
v2 = [111,22,43]

注意：暂不要考虑Python内部的缓存和驻留机制。

目前所有转换为布尔值为False的值有：

0
""
[] or list()
() or tuple()
set()
None

二、字典

字典是 无序、键不重复 且 元素只能是键值对的可变的 容器。

data = { "k1":1,  "k2":2 }

字典的特点：

• 元素必须键值对
• 键不重复，重复则会被覆盖

data = { "k1":1, "k1":2 }
print(data) # {"k1":2}

• 无序（在Python3.6+字典就是有序了，之前的字典都是无序。）

data = { "k1":1,  "k2":2 }
print(data)

2.1 定义

#空字典
v1 = {}
v2 = dict()

data = { 
    "k1":1, 
    "k2":2 
}

info = { 
    "age":12, 
    "status":True,  
    "name":"wupeiqi",   
    "hobby":['篮球','足球']  
}

字典中对键值得要求：

• 键：必须可哈希。 目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict。（集合）
• 值：任意类型。

data_dict = {
	"武沛齐":29,
	 True:5,
	123:5,
    (11,22,33):["alex","eric"]
}

下面的字典定义都是不合法的，因为键是不可哈希的。

# 不合法
v1 = {
    [1, 2, 3]: '周杰伦',
    "age" : 18
} 
v2 = {
    {1,2,3}: "哈哈哈",
    'name':"alex"
} 

v3 = {
    {"k1":123,"k2":456}: '呵呵呵',
    "age":999
}

当我们想要表示一组固定信息时，用字典可以更加的直观，例如：

# 用户列表
user_list = [ {"name":"alex","pwd":"123"}, 
              {"name":"eric","pwd":"123"}
            ]

2.2 独有功能

1. 获取值

info = { 
    "age":12, 
    "status":True, 
    "name":"武沛齐",
    "data":None
}

data1 = info.get("name")
print(data1) # 输出：武沛齐

data2 = info.get("age")
print(data2) # 输出：12

data = info.get("email") # 键不存在，默认返回 None
"""
if data == None:
    print("此键不存在")
else:
    print(data)

if data:
    print(data)
else:
    print("键不存在")
"""

"""
# 字典的键中是否存在 email
if "email" in info:
    data = info.get("email")
    print(data)
else:
	print("不存在")
"""

data = info.get("hobby",123) #如果没有找到对应的键，则返回123
print(data) # 输出：123

# 案例：
user_list = {
    "wupeiqi": "123",
    "alex": "uk87",
}

username = input("请输入用户名：")
password = input("请输入密码：")
# None，用户名不存在
# 密码，接下来比较密码
pwd = user_list.get(username)

if not pwd:
    print("用户名不存在")
else:
    if password == pwd:
        print("登录成功")
	else:
        print("密码错误")
        
# 写代码的准则：简单的逻辑处理放在前面；复杂的逻辑放在后面。

2. 获取所有的键

info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.keys()
print(data) # 输出：dict_keys(['age', 'status', 'name', 'email'])    py2 -> ['age', 'status', 'name', 'email']

result = list(data)
print(result) # ['age', 'status', 'name', 'email']

注意：在Python2中 字典.keys()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。

# 循环
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for ele in info.keys():
    print(ele)

# 是否存在
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
# info.keys() # dict_keys(['age', 'status', 'name', 'email'])
if "age" in info.keys():
    print("age是字典的键")
else:
    print("age不是")

3. 获取所有的值

info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.values()

print(data) # 输出：dict_values([12, True, 'wupeiqi', 'xx@live.com'])

注意：在Python2中 字典.values()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。

# 循环
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for val in info.values():
    print(val) 

# 是否存在
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
if 12 in info.values():
    print("12是字典的值")
else:
    print("12不是")

4. 获取所有的键值对

info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()

print(data) # 输出 dict_items([ ('age', 12),  ('status', True),  ('name', 'wupeiqi'),  ('email', 'xx@live.com')  ])

for item in info.items():
    print(item[0],item[1]) # item是一个元组 (键，值)

for key,value in info.items():
    print(key,value) # key代表键，value代表值，将兼职从元组中直接拆分出来了。

info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()

if ('age', 12) in data:
    print("在")
else:
    print("不在")

5. 设置某个键值对

data = {
    "name": "武沛齐",
    "email": 'xxx@live.com'
}
data.setdefault("age", 18) #如果字典里面没有该键，则更新
print(data)  # {'name': '武沛齐', 'email': 'xxx@live.com', 'age': 18}

data.setdefault("name", "alex") #如果字典里面已经有了该键，则不更新
print(data)  # {'name': '武沛齐', 'email': 'xxx@live.com', 'age': 18}

6. 更新某个键值对

info = {"age":12, "status":True}
info.update( {"age":14,"name":"武沛齐"} )   # info中没有的键直接添加；有的键则更新值
print(info) # 输出：{"age":14, "status":True,"name":"武沛齐"}

7. 移除某个键值对

info = {"age":12, "status":True,"name":"武沛齐"}

data = info.pop("age")

print(info) # {"status":True,"name":"武沛齐"}
print(data) # 12

8. 按照顺序移除（后进先出）

info = {"age":12, "status":True,"name":"武沛齐"}
data = info.popitem() # ("name","武沛齐" )

print(info) # {"age":12, "status":True}
print(data) # ("name","武沛齐")

1. python3.6后，popitem()移除最后的值。
2. python3.6之前，popitem()随机删除。

2.3 公共功能

1. 求并集（Python3.9新加入）

v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}

v3 = v1 | v2
print(v3) # {'k1': 1, 'k2': 22, 'k3': 33}

2. 求长度

info = {"age":12, "status":True,"name":"武沛齐"}
data = len(info)
print(data) # 输出：3

3. 是否包含

info = { "age":12,  "status":True,"name":"武沛齐" }
v1 = "age" in info #True
print(v1)

v2 = "age" in info.keys() #True
print(v2)
#上面两段代码意义相同，都是对键进行遍历
if "age" in info:
    pass
else:
    pass

info = {"age":12, "status":True,"name":"武沛齐"}
v1 = "武佩奇" in info.values()
print(v1)

info = {"age": 12, "status": True, "name": "武沛齐"}
# 输出info.items()获取到的 dict_items([ ('age', 12),  ('status', True),  ('name', 'wupeiqi'),  ('email', 'xx@live.com')  ])

#使用元组对键值对进行搜索
v1 = ("age", 12) in info.items() #True
print(v1)

4. 索引
   字典不同于元组和列表，字典的索引是键，而列表和元组则是 0、1、2等数值 。

info = { "age":12,  "status":True, "name":"武沛齐"}

print( info["age"] )  	    # 输出：12
print( info["name"] )		# 输出：武沛齐
print( info["status"] )	    # 输出：True
print( info["xxxx"] )   	# 报错，通过键为索引去获取之后时，键不存在会报错（以后项目开发时建议使用get方法根据键去获取值）

value = info.get("xxxxx") # None
print(value)

5. 根据键 修改值 和 添加值 和 删除键值对

通过键可以找到字典中的值，也可以对字典进行添加和更新操作。

info = {"age":12, "status":True,"name":"武沛齐"}

info["gender"] = "男"

print(info) # 输出： {"age":12, "status":True,"name":"武沛齐","gender":"男"}

info = {"age":12, "status":True,"name":"武沛齐"}

info["age"] = "18" 

print(info) # 输出： {"age":"18", "status":True,"name":"武沛齐"}

info = {"age":12, "status":True,"name":"武沛齐"}
del info["age"]  # 删除info字典中键为age的那个键值对（键不存在则报错）

print(info) # 输出： {"status":True,"name":"武沛齐"}

info = {"age": 12, "status": True, "name": "武沛齐"}
if "agea" in info:

    # del info["age"]
    data = info.pop("age")
    print(info)
    print(data)
else:
    print("键不存在")

6. for循环

由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环。

info = {"age":12, "status":True,"name":"武沛齐"}
for item in info:
	print(item)  # 所有键

info = {"age":12, "status":True,"name":"武沛齐"}
for item in info.key():
	print(item)

info = {"age":12, "status":True,"name":"武沛齐"}
for item in info.values():
	print(item)

info = {"age":12, "status":True,"name":"武沛齐"}
for key,value in info.items():
	print(key,value)

2.4 转换

特定的列表可以转换为字典。

v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )

print(v) # { "k1":"v1", "k2":"v2" }

info = { "age":12, "status":True, "name":"武沛齐" }

v1 = list(info)        # ["age","status","name"]

v2 = list(info.keys()) # ["age","status","name"]

v3 = list(info.values()) # [12,True,"武沛齐"]

v4 = list(info.items()) # [ ("age",12), ("status",True), ("name","武沛齐") ]

由于字典的键在存储时也是通过哈希函数进行转化，因此在查找某个键的效率是非常高的。

info = {
    "alex":["肝胆","铁锤"], 
	"老男孩":["二蛋","缺货"]
}
v1 = info["alex"]
v2 = info.get("alex")

2.5 嵌套

我们已学了很多数据类型，在涉及多种数据类型之间的嵌套时，需注意一下几点：

• 字典的键必须可哈希（list/set/dict不可哈希）。

info = {
    (11,22):123
}

# 错误
info = {
    (11,[11,22,],22):"alex"
}

• 字典的值可以是任意类型。

info = {
    "k1":{12,3,5},
	"k2":{"xx":"x1"}
}

• 字典的键和集合的元素在遇到 布尔值 和 1、0 时，需注意重复的情况。
• 元组的元素不可以被替换。

dic = {
	'name':'汪峰',
	'age':48,
	'wife':[ {'name':'国际章','age':38},{'name':'李杰','age':48} ],
	'children':['第一个娃','第二个娃']
}
"""
1. 获取汪峰的妻子名字
	d1 = dic['wife'][0]['name']
	print(d1)
2. 获取汪峰的孩子们
	d2 = dic['children']
	print(d2)
3. 获取汪峰的第一个孩子
	d3 = dic['children'][0]
	print(d3)
4. 汪峰的媳妇姓名变更为 章子怡
	dic['wife'][0]['name] = "章子怡"
	print(dic)
5. 汪峰再娶一任妻子
	dic['wife'].append( {"name":"铁锤","age":19} )
	print(dic)
	
6. 给汪峰添加一个爱好：吹牛逼
	dic['hobby'] = "吹牛逼"
	print(dic)
7. 删除汪峰的年龄
	del dic['age']
	或
	dic.pop('age')
	print(dic)
"""

三、浮点型

浮点型，一般在开发中用于表示小数。

v1 = 3.14
v2 = 9.89

关于浮点型的其他知识点如下：

• 浮点型转换为整型时，会将小数部分去掉。

v1 = 3.14 
data = int(v1)
print(data) # 3

• 想要保留小数点后N位

v1 = 3.1415926
result = round(v1,3)
print(result) # 3.142

由于底层存储的原因，在对精确小数进行计算时，会出现以下这个状况：

v1 = 0.1
v2 = 0.2
print(v1 + v2) #3.000000000000004

• 因此在项目中如果遇到精确的小数计算时

import decimal

v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3

总结

1. 集合，是 无序、不重复、元素必须可哈希、可变的一个容器（子孙元素都必须是可哈希）。

2. 集合的查找速度比较快（底层是基于哈希进行存储）

3. 集合可以具有 交并差 的功能。

4. 字典是 无序、键不重复 且 元素只能是键值对的可变的一个容器（键子孙元素都必须是可哈希）。

5. py3.6+之后字典就变为有序了。

6. py3.9 新增了一个 {} | {}运算。

7. 字典的常见功能。

8. 在python2和python3中，字典的 keys() 、values()、items() 三个功能获取的数据类型不一样。

9. None是代表内存中的一个空值。

#以下转换为布尔值时均为False
0
""
[] or list()
() or tuple()
set()
None
{} or dict()

10. 浮点型用于表示小数，但是由于其内部存储原理可能会引发数据存储不够精准。