day06 数据类型（下）

​

常见的数据类型：

• dict，字典类型

• set，集合类型

• float，浮点类型（浮点型）

目标：掌握字典、集合、浮点类型相关知识。

课程概要：

• set集合，一个不允许重复重复 & 可变类型（元素可哈希）。

• dict字典，一个容器且元素必须是键值对。

• float类型，我们生活中常见的小数。

1.集合（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. 添加元素

   data = {"刘嘉玲", '关之琳', "王祖贤"}
   data.add("郑裕玲")
   print(data)
   data = set()
   data.add("周杰伦")
   data.add("林俊杰")
   print(data)

   

    

2. 删除元素

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

   

    

3. 交集

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

   

    

4. 并集

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

   

    

5. 差集

   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)

   

    

1.3 公共功能

1. 减，计算差集

   s1 = {"刘能", "赵四", "⽪⻓⼭"}
   s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
   
   s3 = s1 - s2 
   s4 = s2 - s1
   print(s3)
   print(s4)

   

    

2. &，计算交集

   s1 = {"刘能", "赵四", "⽪⻓⼭"}
   s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
   s3 = s1 & s2
   print(s3)

   

    

3. |，计算并集

   s1 = {"刘能", "赵四", "⽪⻓⼭"}
   s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
   s3 = s1 | s2
   print(s3)

   

    

4. 长度

   v = {"刘能", "赵四", "尼古拉斯"}
   data = len(v)
   print(data)

   

    

5. for循环

   v = {"刘能", "赵四", "尼古拉斯"}
   for item in v:
   	print(item)

   

    

1.4 转换

其他类型如果想要转换为集合类型，可以通过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 = {11,22,33,3,99}

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

v2 = tuple(data) # (11,22,33,3,99)

1.5 其他

1.5.1 集合的存储原理​编辑

1.5.2 元素必须可哈希

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

目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。

总结：集合的元素只能是 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) 

  

   

1.5.3 查找速度特别快

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

• 低

  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("不在")

  

   

1.5.4 对比和嵌套

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}

强插：None类型

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

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

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

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

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

0
""
[] or list()
() or tuple()
set()
None
if None:
    pass

2.字典（dict)

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

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
}
data_dict = {
    1: 29,
    True: 5
}
print(data_dict) # {1: 5}

一般在什么情况下会用到字典呢？

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

# 用户列表
user_list = [ ("alex","123"), ("admin","666") ]
...
# 用户列表
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)
   print(data) # 输出：123

   

   # 案例：

   user_list = {
       "wupeiqi": "123",
       "alex": "uk87",
   }
   
   username = input("请输入用户名：")
   password = input("请输入密码：")
   # None，用户名不存在
   # 密码，接下来比较密码
   pwd = user_list.get(username)
   
   if pwd == None:
       print("用户名不存在")
   else:
       if password == pwd:
           print("登录成功")
   	else:
           print("密码错误")

   

   # 案例：

   user_list = {
       "wupeiqi": "123",
       "alex": "uk87",
   }
   
   username = input("请输入用户名：")
   password = input("请输入密码：")
   # None，用户名不存在
   # 密码，接下来比较密码
   pwd = user_list.get(username)
   
   if pwd:
       if password == pwd:
           print("登录成功")
   	else:
           print("密码错误")
   else:
       print("用户名不存在")

   

   # 案例：

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

   

   • py3.6后，popitem移除最后的值。

   • py3.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
   print(v1)
   
   v2 = "age" in info.keys()
   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()
   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","武沛齐") ]

1.5 其他

1.5.1 存储原理​编辑

1.5.2 速度快

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

1.5.3 嵌套

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

• 字典的键必须可哈希（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)
"""

3.浮点型（float）

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

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

  

   

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

  底层原理视频：float浮点型底层存储原理【0.1+0.2 不等于 0.3，不服来战】_哔哩哔哩_bilibili

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

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是代表内存中的一个空值。

   0
   ""
   [] or list()
   () or tuple()
   set()
   None
   {} or dict()

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

​

本栏目推荐文章
• 代码随想录 day18 找树左下角的值 路径总和 从中序与后序遍历序列构造二叉树
• Jmeter 如何连接mysql数据库？
• 函数的参数类型
• SQL Server 检测是不是数字型数据的两种方法
• 如何通过Navicat把MySQL远程数据库导入到本地数据库
• 和利时MACS6通过dat文件实现任意时间范围与测点的历史数据提取与科研分析
• 深入理解spring框架：剖析多线程模式下数据库连接
• 数据可视化是如何帮助大型企业提高效率的？
• Scala编程语言day1
• 2024-1-13 DAY4

类型 数据 day 06类型 数据day 06 类型 数据day 03 类型 数据day2 day datawhale类型 数据day3 类型 布尔 数据day 类型 数据java day pixel day 06 day 06 类型 数据day 04 类型 数据python day