day04-数据类型（下）

1.集合

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

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(2)
print(v1)	# {11,22,33,44}

一般什么时候用集合呢？
就是想要维护一大堆不重复的数据时，就可以用它。
注意：定义空集合时，只能使用v=set()，不能使用v={}（这样是定义一个空字典）。

1.2 独有功能

1. 添加元素

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

data = set()
data.add("周杰伦")
data.add("林俊杰")
print(data)

2. 删除元素

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

3. 交集

s1 = {"刘能","赵四","皮长山"}
s2 = {"刘科长","冯乡长","皮长山"}
s3 = s1 & s2	# 取两个集合的交集
s4 = s1.intersection(s2)	# 取两个集合的交集
print(s3,s4)

4. 并集

s1 = {"刘能","赵四","皮长山"}
s2 = {"刘科长","冯乡长","皮长山"}
s3 = s1 | s2	# 取两个集合的并集
s4 = s1.union(s2)	# 取两个集合的并集
print(s3,s4)

5. 差集

s1 = {"刘能","赵四","皮长山"}
s2 = {"刘科长","冯乡长","皮长山"}
s3 = s1 - s2	# 取两个集合的差集，s1中有s2中没有的
s4 = s1.difference(s2)	# 取两个集合的并集
print(s3,s4)

s5 = s2 - s1	# 取两个集合的差集，s2中有s1中没有的
s6 = s2.difference(s1)	# 取两个集合的差集，s2中有s1中没有的
print(s5,s6)

1.3 公共功能

1. 减，计算差集

s1 = {"刘能","赵四","皮长山"}
s2 = {"刘科长","冯乡长","皮长山"}
s3 = s1 - s2
s4 = s2 - s1
print(s3,s4)

2. &，计算交集

s1 = {"刘能","赵四","皮长山"}
s2 = {"刘科长","冯乡长","皮长山"}
s3 = s1 & s2
print(s3)

3. |，计算并集

s1 = {"刘能","赵四","皮长山"}
s2 = {"刘科长","冯乡长","皮长山"}
s3 = s1 | s2
print(s3)

4. 长度

s1 = {"刘能","赵四","皮长山"}
data = len(s1)
print(data)

5. for循环

s1 = {"刘能","赵四","皮长山"}
for item in s1:
	print(item)

1.4 转换

其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。
提示：int/list/tuple/dict都可以转换为集合。

v1 = "吴佩琦"
v2 = set(v1)
print(v2)	# {'佩', '吴', '琦'}

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

v1 = (11,22,33,44,55)
v2 = set(v1)
print(v2)	# {11,22,33,44,55}

data = {11,22,33,44}
v1 = list(data)		# [11,22,33,44]
v2 = tuple(data)	# (11,22,33,44)

1.5 其他

1.5.1 集合的存储原理

1.5.2 元素必须可哈希

因存储原理，集合的元素必须是可哈希的值，即：内部通过哈希函数把值转换成一个数字。

目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。
总结：集合的元素只能是int、bool、str、tuple

• 转换成功

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

• 转换失败

v1 = [11,22,["alex","eric"],33]
v2 = set(v1)
print(v2)

1.5.3 查找速度特别快

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

• 低

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

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

• 效率高

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

1.5.4 对比和嵌套

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

# 集合中有列表，会报错
data_list = [
	"alex", 
	11, 
	(11, 22, 33, {"alex"}, 22), 
	[11, 22, 33], 
	{11, 22, (True, ["中国"])}
]

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

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

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

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

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

练习题

1. 写代码实现

v1 = {"alex", "武sir", "肖大"}
v2 = []

# 循环提示用户输入，如果输入值在v1中存在，则追加到v12中，如果v1中不存在，则添加到v1中（如果输入N或n则停止循环）
while True:
    s = input("请输入(N/n退出)：")
    if s == "N" or s == "n":
        break
    if s in v1:
        v2.append(s)
    else:
        v1.add(s)

2. 下面哪些值不能做集合的元素

""
0
[11,22,33]	# 不能
[]	# 不能
(123)
{1,2,3}		# 不能

3. 模拟用户信息录入程序，已录入则不再创建

user_info_set = set()
while True:
    name = input("请输入姓名：")
    age = input("请输入年龄")
    item = (name, age,)
    if item in user_info_set:
        print("用户已录入")
    else:
        user_info_set.add(item)

强插：None类型

python的数据类型中有一个特殊的值None，意味着这个值啥都不是或表示空，相当于其他语言中null作用一样。
在一定程度上可以帮助我们去节省内存，例如：

v1 = None
v2 = None
.....
v1 = [11,22,33]
v2 = [111,222,333]

v3=[]
v4=[]
.....
v3 = [11,22,33]
v4 = [111,222,333]

注意：暂不要考虑python内部的缓存和驻留机制
目前所有转换为布尔值为False的值有：

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

2.字典

字典是无序、键不重复且元素只能是键值对的可变的容器
data = {"k1":1,"k2":2}

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

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

• 无序(在python3.6+字典就是有序了，之前的字典都是无序。)

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

2.1 定义

v1 = {}
v2 = dict()

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

info = {
	"age":12,
	"status":True,
	"name":"wupeiqi"
}

字典中对键值的要求：

• 键：必须可哈希。目前为止学到的可哈希的类型：int、bool、str、tuple；不可哈希的类型：list、set、dict
• 值：任意类型
  一般在什么情况下会用到字典呢？
  当我们想要表示一组固定信息时，用字典可以更加的直观。

2.2 独有功能

1. 获取值

info = {"age": 12, "status": True, "name": "武沛齐"}
data1 = info.get("name")
print(data1)    # 武沛齐
data2 = info.get("email")   # 键不存在，默认返回None
print(data2)
data3 = info.get("hobby", 123)
print(data3)    # 123

2. 所有的键

info = {"age": 12, "status": True, "name": "武沛齐"}
data = info.keys()
print(data)     # dict_keys(['age', 'status', 'name'])

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

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

3. 所有的值

info = {"age": 12, "status": True, "name": "武沛齐"}
data = info.values()
print(data)     # dict_values([12, True, '武沛齐'])

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

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

4. 所有的键值

info = {"age": 12, "status": True, "name": "武沛齐"}
data = info.items()
print(data)     # dict_items([('age', 12), ('status', True), ('name', '武沛齐')])

info = {"age": 12, "status": True, "name": "武沛齐"}
for item in info.items():
    print(item)		# item是一个元组

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

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()
print(info)     # {'age': 12, 'status': True}
print(data)     # ('name', '武沛齐')

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. 长度

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

3. 是否包含

v1 = {"k1": 1, "k2": 2}
r1 = "k1" in v1
print(r1)   # True

4. 索引（键）

v1 = {"k1": 1, "k2": 2}
print(v1["k1"])     # 1
print(v1["k2"])     # 2

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"]
print(info)     # {'status': True, 'name': '武沛齐'}

6. for循环

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

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

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

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

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', '武沛齐')]

2.5 其他

2.5.1 存储原理

2.5.2 速度快

info = {'age': 12, 'status': True, 'name': '武沛齐'}
if "age" in info:
    print("在")

2.5.3 嵌套

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

• 字典的键必须可哈希。（list、set、dict不可哈希）
• 字典的值可以是任意类型。
• 集合元组必须可哈希。（list、set、dict不可哈希）
• 字典的键和集合的元素在遇到布尔值时，需注意重复的情况。

3.浮点型

浮点型，一般在开发中用于表示小数。
关于浮点型的其他知识点如下：

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

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

• 想要保留小数点后N位。

v1 = 3.1415354
data = round(v1, 3)
print(data)     # 3.142

• 浮点型的坑（所有语言中）

v1 = 0.1
v2 = 0.2
v3 = v1 + v2
print(v3)       # 0.30000000000000004

在项目中如果遇到精确的小数计算应该怎么办？

import decimal

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

作业

dic = {"k1": "v1", "k2": "v2", "k3": [11, 22, 33]}
dic["k4"] = "v4"
print(dic)      # {'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
dic["k1"] = "alex"
print(dic)      # {'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
dic["k3"].append(44)
print(dic)      # {'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33, 44], 'k4': 'v4'}
dic["k3"].insert(0, 18)
print(dic)      # {'k1': 'alex', 'k2': 'v2', 'k3': [18, 11, 22, 33, 44], 'k4': 'v4'}

dic1 = {
    "name": ['alex', 2, 3, 5],
    'job': 'teacher',
    'oldboy': {'alex': ['python1', 'python2', 100]}
}

dic1['name'].append("wusir")
print(dic1)     # {'name': ['alex', 2, 3, 5, 'wusir'], 'job': 'teacher', 'oldboy': {'alex': ['python1', 'python2', 100]}}
new_name = dic1['name'][0].upper()
dic1['name'][0] = new_name
print(dic1)     # {'name': ['ALEX', 2, 3, 5, 'wusir'], 'job': 'teacher', 'oldboy': {'alex': ['python1', 'python2', 100]}}
dic1['oldboy'].update({"老男孩":'linux'})
print(dic1)     # {'name': ['ALEX', 2, 3, 5, 'wusir'], 'job': 'teacher', 'oldboy': {'alex': ['python1', 'python2', 100], '老男孩': 'linux'}}
dic1['oldboy']['alex'].remove('python2')
print(dic1)     # {'name': ['ALEX', 2, 3, 5, 'wusir'], 'job': 'teacher', 'oldboy': {'alex': ['python1', 100], '老男孩': 'linux'}}

info = {}

while True:
    text = input("请输入内容")
    if text.upper() == 'N':
        break
    data_list = text.split("|")
    info[data_list[0]] = data_list[1]

第一个可以
第二个可以
第三个可以
第四个可以
第五个不可以
第六个可以
第七个不可以
第八个不可以

key_list = []
value_list = []
dic = {"k1": "v1", "k2": "v2", "k3": "v3"}
for key, value in dic.items():
    key_list.append(key)
    value_list.append(value)
print(key_list)
print(value_list)

dic = {"k1": "v1", "k2": "v2", "k3": [11, 22, 33]}
for key in dic.keys():
    print(key)
for value in dic.values():
    print(value)
for key, value in dic.items():
    print(key, value)
dic["k4"] = "v4"
print(dic)
dic["k1"] = "alex"
print(dic)
dic['k3'].append(44)
print(dic)
dic['k3'].insert(1, 18)
print(dic)

info = {
    'k1': 'v1',
    'k2': [('alex'), ('wupeiqi'), ('oldboy')],
}
for value in info['k2']:
    print(value)

str1 = "k:1|k1:2|k2:3|k3:4"
data_list = str1.split("|")
dic = {}
for item in data_list:
    dic[item.split(":")[0]] = int(item.split(":")[1])
print(dic)

li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
result = {'k1': [], 'k2': []}
for i in li:
    if i > 66:
        result['k1'].append(i)
    elif i == 66:
        pass
    else:
        result['k2'].append(i)
print(result)   # {'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55, 66]}

goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "游艇", "price": 20},
    {"name": "美女", "price": 998},
]
for i in range(len(goods)):
    str1 = str(i+1)
    for value in goods[i].values():
        str1 = str1 + " " + str(value)
    print(str1)

while True:
    index = input("请输入商品序号：")
    if index.upper() == 'Q':
        break
    if index.isdecimal():
        index = int(index)
        if 0 < index < 5:
            print(goods[index-1]['name'], goods[index-1]['price'])
        else:
            print("商品序号输入有误，请重新输入")
    else:
        print("商品序号输入有误，请重新输入")

goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "游艇", "price": 20},
    {"name": "美女", "price": 998},
]
for i in range(len(goods)):
    str1 = str(i+1)
    for value in goods[i].values():
        str1 = str1 + " " + str(value)
    print(str1)

while True:
    index = input("请输入商品序号：")
    if index.upper() == 'Q':
        break
    if not index.isdecimal():
        print("商品序号输入有误，请重新输入")
        break
    index = int(index)
    if 0 < index < 5:
        print(goods[index - 1]['name'], goods[index - 1]['price'])
    else:
        print("商品序号输入有误，请重新输入")