Python数据类型进阶——详解

  

                                       —— 小 峰 编 程

目录

1.整型

1.1 定义

1.2 独有功能

1.3 公共功能

1.4 转换

1.5 其他

1.5.1 长整型

1.5.2 地板除(除法）

2. 布尔类型

2.1 定义

2.2 独有功能

2.3 公共功能

2.4 转换

2.5 其他

 做条件自动转换

3.字符串类型

3.1 定义

3.2 独有功能（18/48）

3.3 公共功能

3.4 转换

3.5 其他

4.列表（list）

1.1 定义

1.2 独有功能

1.3 公共功能

 5.元组

5.1 定义

5.2 独有功能

5.3 公共功能

5.4 转换

5.5 其他

嵌套

6.集合（set）

6.1 定义

6.2 独有功能

6.3 公共功能

6.4 转换

6.5 其他

6.5.1 集合的存储原理

6.5.2 元素必须可哈希

6.5.3 查找速度特别快

6.5.4 对比和嵌套

补充：None类型

7.字典（dict)

7.1 定义

7.2 独有功能

7.3 公共功能

7.4 转换

7.5 其他

1.5.1 存储原理

1.5.2 速度快

1.5.3 嵌套

8.浮点型（float）

---

序言： 在前面Python的第一讲中，我们其实已经对数据类型已经有了初步的认识。接下来在本讲中我们会针对Python中的数据类型做以详细的讲解。每种数据类型的讲解，会按照以下4个维度来进行：定义、独有功能、公共功能、类型转换、其他等几个方面来进行讲解。常见的数据类型：

• int，整数类型（整形）
• bool，布尔类型
• str，字符串类型
• list，列表类型
• tuple，元组类型
• dict，字典类型
• set，集合类型
• float，浮点类型（浮点型）

1.整型

•  整型其实就是十进制整数的统称，比如：1、68、999都属于整型。他一般用于表示 年龄、序号等。

1.1 定义

number = 10
age = 99

1.2 独有功能

• 无

# 调用v1（int）,v2(int)的独有功能，获取v1,v2的二进制有多少个位组成。
v1=10
v2=5
print(bin(v1),bin(v2))#0b1010 0b101
print(v1.bit_length(),v2.bit_length())#4 3

1.3 公共功能

• 加减乘除

v1 = 4
v2 = 8
v3 = v1 + v2

1.4 转换

• 在项目开发和面试题中经常会出现一些 “字符串” 和 布尔值 转换为 整型的情况。

# 布尔值转整型
print(int(True),int(False)) #1 0 True转换为整数 1  False转换为整数 0
# 字符串转整型
print(int("250",base=10))#把字符串看成十进制数字
print(int("0b101",base=2))#把字符串看成二进制数字
print(int("0o11",base=8))#把字符串看成八进制数字
print(int("0x10",base=16))#把字符串看成十六进制数字
#print(int("scbsbc"))#不能转换
# 浮点型（小数）
v1 = int(8.7) # 8

Tip: 所以，如果以后别人给你一个按 二进制、八进制、十进制、十六进制 规则存储的字符串时，可以轻松的通过int转换为十进制的整数。

1.5 其他

1.5.1 长整型

• Python3：整型（无限制）
• Python2：整型、长整形

>>>>在python2中跟整数相关的数据类型有两种：int(整型)、long（长整型），他们都是整数只不过能表示的值范围不同。

• int，可表示的范围：-9223372036854775808～9223372036854775807
• long，整数值超出int范围之后自动会转换为long类型（无限制）。

>>>>在python3中去除了long只剩下：int（整型），并且 int 长度不在限制。

1.5.2 地板除(除法）

• Py3：

  v1 = 9/2 
  print(v1) # 4.5
  

• py2:

  v1 = 9/2 
  print(v1) # 4
  

2. 布尔类型

• 布尔值，其实就是 “真”、“假” 。

2.1 定义

a = False
b = True

2.2 独有功能

• 无

2.3 公共功能

• 无

print(True+False,True-True)#1 0

2.4 转换

• 在以后的项目开发中，会经常使用其他类型转换为布尔值的情景，此处只要记住一个规律即可。整数0、空字符串、空列表、空元组、空字典转换为布尔值时均为False，其他均为True。

# 练习题：查看一些变量为True还是False
print(bool(0))
print(bool(-10))
print(bool(10))
print(bool("武齐"))
print(bool(""))
print(bool(" "))
print(bool([]) )# [] 表示空列表
print(bool([11,22,33])) # [11，22，33] 表示非空列表
print(bool({})) # {} 表示空字典
print(bool({"name":"武齐","age":18}))# {"name":"武齐","age":18} 表示非空字典

2.5 其他

•  做条件自动转换

        如果在 if 、while 条件后面写一个值当做条件时，他会默认转换为布尔类型，然后再做条件判断。

if 0:print("太六了")
else:print(999)if "武齐":print("你好")if "alex":print("你是王？")
else:print("你是李？")

while 1<9:pass

if 值:passwhile 值:pass

3.字符串类型

• 字符串，我们平时会用他来表示文本信息。例如：姓名、地址、自我介绍等。

3.1 定义

v1 = "包治百病"
v2 = '包治百病'
v3 = "包'治百病"
v4 = '包"治百病'
v5 = """
吵架都是我的错，
因为大家打不过。
"""
# 三个引号，可以支持多行/换行表示一个字符串，其他的都只能在一行中表示一个字符串。

3.2 独有功能（18/48）

"xxxxx".功能(...)v1 = "xxxxx"
v1.功能(...)

1. 判断字符串是否以 XX 开头？得到一个布尔值

   v1 = "每天事情都好多，烦死了"
   # True
   result = v1.startswith("每天")
   print(result) # 值为True
   

   v1 = input("请输入住址：")
   if v1.startswith("北京"):print("北京人口")
   else:print("非北京人口")

2. 判断字符串是否以 XX 结尾？得到一个布尔值

   v1 = "每天事情真多，烦死了"
   result = v1.endswith("烦死了")
   print(result) # 值为True
   

   # 案例
   address = input("请输入地址：")
   if address.endswith('村'):print("农业户口")
   else:print("非农户口")
   

3. 判断字符串是否为十进制数？得到一个布尔值

   v1 = "1238871"
   result = v1.isdecimal()
   print(result) # True
   

   # 案例,两个数相加。
   v1 = input("请输入值：") # ”666“
   v2 = input("请输入值：") # ”999“
   if v1.isdecimal() and v2.isdecimal():data = int(v1) + int(v2)print(data)
   else:print("请正确输入数字")
   

   v1 = "123"
   print(v1.isdecimal()) # True
   v2 = "①"
   print(v2.isdecimal()) # False 判断是否由十进制数字字符组成
   v3 = "123"
   print(v3.isdigit()) # True 判断是否由数字字符组成
   v4 = "①"
   print(v4.isdigit()) # True
   

4. 去除字符串两边的 空格、换行符、制表符，得到一个新字符串

   msg = " H e ll o，哥 "
   print(msg.strip(),msg.rstrip(),msg.lstrip())
   # 分别将msg两边，右边，左边的空白去掉
   

   补充：去除 空格、换行符、制表符。

   # 案例
   code = input("请输入4位验证码：") #  FB87 
   data = code.strip()
   if data == "FB87":print('验证码正确')
   else:print("验证码错误")
   

   补充：去除字符串两边指定的内容。

5. 字符串变大写，得到一个新字符串

   # 案例
   code = input("请输入4位验证码：") #  FB88   fb88 
   value = code.upper() #  FB88  
   data = value.strip() # FB88
   if data == "FB87":print('验证码正确')
   else:print("验证码错误")
   # 注意事项
   """
   code的值"fb88 "
   value的值"FB88 "
   data的值"FB88"
   """
   

6. 字符串变小写，得到一个新字符串

   # 案例
   code = input("请输入4位验证码：")
   value = code.strip().lower()
   if value == "fb87":print('验证码正确')
   else:print("验证码错误")
   

7. 字符串内容替换，得到一个新的字符串

   # 案例
   video_file_name = "西游记.mp4"
   new_file_name = video_file_name.replace("mp4","avi") # "西游记.avi"
   final_file_name = new_file_name.replace("西游记","水浒传") # "水浒传.avi"
   print(final_file_name)
   

8. 字符串切割，得到一个列表

   # 案例：判断用户名密码是否正确
   info = xiaofeng,root"   # 备注：字符串中存储了用户名和密码
   user_list = info.split(',')    # 得到一个包含了2个元素的列表 [ "武沛齐" , "root" ]
   # user_list[0]  user_list[1]
   user = input("请输入用户名：")
   pwd = input("请输入密码：")
   if user == user_list[0] and pwd == user_list[1]:print("登录成功")
   else:print("用户名或密码错误")
   

   扩展

   data = "武沛齐,root,wupeiqi@qq.com"
   v1 = data.rsplit(',')
   print(v1) # ['武沛齐', 'root', 'wupeiqi@qq.com']
   v2 = data.rsplit(',',1) #从最右边开始分割，最多分割一次
   print(v2) # ['武沛齐,root', 'wupeiqi@qq.com']
   

   应用场景：

   #经常用于对IP地址的分割
   file_path = "xxx/xxxx/xx.xx/xxx.mp4"
   data_list = file_path.rsplit(".",1) # ["xxx/xxxx/xx.xx/xxx","mp4"]
   data_list[0]
   data_list[1]
   

9. 字符串拼接，得到一个新的字符串

   data_list = ["xiaofeng","是","小白"]
   v1 = "_".join(data_list) 
   print(v1)
   

10. 格式化字符串，得到新的字符串

    print("_".join(data))
    name="{name}已经{age}岁了。".format(name="xiaofeng",age=20)

11. 字符串转换为字节类型

    data = "饺子"  # unicode，字符串类型
    v1 = data.encode("utf-8")  # utf-8，字节类型
    v2 = data.encode("gbk")  # gbk，字节类型
    print(v1)  # b'\xe5\xab\x82 \xe5\xad\x90'
    print(v2)  # b'\xc9\xa9 \xd7\xd3'
    s1 = v1.decode("utf-8") 
    s2 = v2.decode("gbk") 
    print(s1)
    print(s2)
    

12. 将字符串内容居中、居左、居右展示

    v1="xiaofeng"
    print(v1.center(18,"*"))
    print(v1.rjust(18,"*"))
    print(v1.ljust(18,"*"))
    

13. 帮助你填充0

    # 应用场景：处理二进制数据
    data = "101" # "00000101"
    v1 = data.zfill(8)
    print(v1) # "00000101"
    

3.3 公共功能

1. 相加：字符串 + 字符串

   print("xiao"+"feng")

2. 相乘：字符串 * 整数

   print( "xiaofeng" * 3)

3. 长度

   value = len("xiaofeng") 
   print(value) # 8
   

4. 获取字符串中的字符，索引

   a="来这里吃点东西"0 1 2 3 4 5 6-7   ...    -1
   print(a[0])
   print(a[-1])
   

   注意：字符串中是能通过索引取值，无法修改值。【字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。】

5. 获取字符串中的子序列，切片

   message = "来吃点py东西呀"
   #          0 1 2345 6 7
   print(message[0:2]) # "来吃"
   print(message[3:7]) # "py东西"
   print(message[3:] ) # "py东西呀"
   print(message[:5] ) # "来吃点py"
   print(message[4:-1]) # "y东西"
   print(message[4:-2]) # "y东"
   print(message[4:len(message)] ) # "y东西呀"
   print(message[::-1])#相当于字符串逆置/倒序
   

6. 步长，跳着去字符串的内容

   data="生活不是电影，生活比电影苦"
   print(data[0:len(data):2])
   #从第一个位置到最后一个位置，步长为2的切片
   print(data[0::2])
   #逆序切片
   print(data[::-1])
   print(data[::-2])

7. 循环

   • while循环

     data="好好学习编程技术"
     i=0
     while i<len(data):print(data[i],end='')i+=1
     

   • for循环

     data='好好学习编程技术'
     for i in data:print(i,end='')
     

   • range，帮助我们创建一系列的数字

     range(10) # [0,1,2,3,4,5,6,7,8,9]
     range(1,10) # [1,2,3,4,5,6,7,8,9]
     range(1,10,2) # [1,3,5,7,9]
     range(10,1,-1) # [10,9,8,7,6,5,4,3,2]
     

   • For + range

     for i in range(11):print(i,end=' ')

     message = "好好学习"
     for i in range( len(message) ): print(message[i])
     

   一般应用场景：

   • while，一般在做无限制（未知）循环此处时使用。

     while True:...
     

     # 用户输入一个值，如果不是整数则一直输入，直到是整数了才结束。
     num = 0
     while True:data = input("请输入内容:")if data.isdecimal():num = int(data)breakelse:print("输入错误，请重新输入！")
     

   • for循环，一般应用在已知的循环数量的场景。

     message = "好好学习编程技术"
     for char in message:print(char)
     

     for i in range(30):print(message[i])
     

   • break和continue关键字

     message="好好学习编程技术"
     for char in message:if char=='习':continueprint(char,end='')

     message="好好学习编程技术"
     for char in message:if char=='习':breakprint(char,end='')

3.4 转换

num = 999
data = str(num)
print(data) # "999"

num =["小峰",11,["xiaowang"]]
z=str(num)
print(z,type(z))

一般情况下，只有整型转字符串才有意义。

3.5 其他

• 字符串不可被修改

name="xiao峰"
print(name[1])
name[1]='x'   #不支持修改，会报错
print(name)

4.列表（list）

• 列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

1.1 定义

number_list = [98,88,666,12,-1]
data_list = [1,True,"xiaofeng","宝强","贾乃亮"]

data = list()
#data = [] 以上这两种方式都不表示空列表
print(data)

补充：

• 不可变类型：字符串、布尔、整型（已最小，内部数据无法进行修改）
• 可变类型：列表（内部数据元素可以修改）

1.2 独有功能

Python中为所有的列表类型的数据提供了一批独有的功能。在开始学习列表的独有功能之前，先来做一个字符串和列表的对比：

• 字符串，不可变，即：创建好之后内部就无法修改。【独有功能都是新创建一份数据】

• 列表，可变，即：创建好之后内部元素可以修改。【独有功能基本上都是直接操作列表内部，不会创建新的一份数据】

列表中的常见独有功能如下：

1. 追加，在原列表中尾部追加值。

   user_list = ["语文","数学"]
   user_list.append("英语")
   print(user_list) # ["语文","数学","英语"]
   

   welcome="欢迎来到游戏".center(30,"*")
   print(welcome)
   user_count=0
   while True:user_count=input("请输入玩游戏的人数：")if user_count.isdecimal():user_count=int(user_count)breakelse:print("输入的需要是数字，请重新输入！")
   message=f"有{user_count}参加游戏"
   print(message)
   user_name=[]
   for i in range(1,user_count+1):tips=f"请输入玩家姓名{i}/{user_count}:"name=input(tips)user_name.append(name)
   print(user_name)

2. 批量追加，将一个列表中的元素逐一添加另外一个列表。

   data = ['xiaoli',20,'男']
   data.extend(['xiaowang',23,'女'])
   print(data)

3. 插入，在原列表的指定索引位置插入值

   user_list = ["小王","雪","小张"]
   user_list.insert(0,"马蓉")
   user_list.insert(2,"李小璐")
   print(user_list)
   

4. 在原列表中根据值删除（从左到右找到第一个删除）【慎用，里面没有会报错】

   user_list = ["小王","雪","小张","雪"]
   while True:if "雪" in user_list:user_list.remove("雪")else:break
   print(user_list)

   # 案例：自动抽奖程序
   import randomdata_list = ["iphone12", "购物卡", "洗手液", "泰国5日游"]while data_list:name = input("自动抽奖程序，请输入自己的姓名：")# 随机从data_list抽取一个值出来value = random.choice(data_list) print( "恭喜{}，抽中{}.".format(name, value) )data_list.remove(value) 

5. 在原列表中根据索引踢出某个元素（根据索引位置删除）

   user_list = ["王宝强","陈羽凡","Alx","贾乃亮","Alx"]
   #               0       1      2      3       4
   user_list.pop(1)  #会自动返回，删除索引上对应的值
   print(user_list) #  ["王宝强","Alx","贾乃亮","Alx"]user_list.pop()
   print(user_list) # ["王宝强","Ale","贾乃亮"]

   # 案例：排队买火车票
   user_queue=[]
   ticket=5
   while True:name=input("请输入你的名字进行排队购买(Q退出)：")if name=="Q":breakelse:user_queue.append(name)
   for i in range(ticket):if ticket <=ticket and len(user_queue) > 0:print(f"恭喜{user_queue.pop()}，买票成功")
   if len(user_queue) >0:print(f"票数不足！非常抱歉，票已售完，以下几位用户请选择其他出行方式，名单：{user_queue}.")

6. 清空原列表

   user_list = ["小王","雪","小张","雪"]
   user_list.clear()
   print(user_list)
   

7. 根据值获取索引（从左到右找到第一个删除）【慎用，找不到报错】

   user_list =["小王","雪","xiaofeng","雪"]
   #              0    1     2         3    
   if "xiaofeng" in user_list:index = user_list.index("xiaofeng")print(index) # 2
   else:print("不存在")
   

8. 列表元素排序

   user_list = ["小王","雪","小张","雪"]
   user_list.sort() #按照对应的码值比较
   print(user_list)
   num=[4,7,2,1]
   num.sort()#由小到大
   print(num)
   num.sort(reverse=True)#由大到小
   print(num)
   

   注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）。

9. 反转原列表

   user_list = ["小王","雪","小张","雪"]
   user_list.reverse()
   print(user_list)

1.3 公共功能

1. 相加，两个列表相加获取生成一个新的列表。

   data = ["赵四","刘能"] + ["宋晓峰","范德彪"]
   print(data) # ["赵四","刘能","宋晓峰","范德彪"]

2. 相乘，列表*整型 将列表中的元素再创建N份并生成一个新的列表。

   data = ["赵四","刘能"] * 2
   print(data) # ["赵四","刘能","赵四","刘能"]
   

3. 运算符in包含 由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中。

   user_list = ["小王","雪","xiaofeng","雪"]
   result = "xiaofeng" in user_list
   print(result)

 5.元组

5.1 定义

• 列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素（可重复）。
• 元组（tuple），是一个有序且不可变的容器，在里面可以存放多个不同类型的元素。

d1 = (1)  # 1
d2 = (1,) # (1,)
d3 = (1,2)
v3 = (True,123,"xiaofeng",[11,22,33,44])
# 建议：议在元组的最后多加一个逗v3 = ("李杰","xiaofeng",)

注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。

# 面试题
1. 比较值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别？
2. 比较值 v1 = ( (1),(2),(3) ) 和 v2 = ( (1,) , (2,) , (3,),) 有什么区别？

5.2 独有功能

无

5.3 公共功能

1. 相加，两个列表相加获取生成一个新的列表。

   print((1,4)+(2,5))

2. 相乘，列表*整型 将列表中的元素再创建N份并生成一个新的列表。

   print((1,3)*2)

3. 获取长度

   data=('xiao',3,6)
   print(len(data))

4. 索引

   data=('xiao',3,6)
   print(data[1])

5. 切片

   data=('xiao',3,6)
   print(data[:1:])
   print(data[1::2])
   print(data[2::-1])

6. 步长

   data=('xiao',3,6)
   print(data[::2])
   print(data[1::2])
   print(data[2::-1])
   

7. for循环

   data=('xiao',3,6)
   for i in data:print(i)

   # len + range + for + 索引
   user_list = ​('xiao',3,6)
   for index in range(len(user_list)):item = user_list[index]print(item)
   

5.4 转换

其他类型转换为元组，使用tuple(其他类型)，截止目前只有字符串和列表可以转换为元组。

data = tuple(其他)

name = "xiaofeng"
data = tuple(name)
print(data)

name = ["武齐",18,"python"]
data = tuple(name)
print(data) # 输出 ("武齐",18,"python")

5.5 其他

• 嵌套

        由于元组和列表都可以充当容器，他们内部可以放很多元素，并且也支持元素内的各种嵌套。元组的元素不能被替换，但元组的元素如果是可变类型，可变类型内部是可以修改的。

data = ('xiao','wang',['zhang','li','qin'])
print(data[0])
print(data[2])
print(data[2][0])
print(data[2][1][1])
data[2][1]='liu'
print(data)

案例：动态的创建用户并添加到用户列表中。

# 创建用户 5个
# user_list = [] # 用户信息
while True:user = input("请输入用户名：")if user == "Q":brekpwd = input("请输入密码：")item = (user,pwd,)user_list.append(item)# 实现：用户登录案例
print("登录程序")
username = input("请输入用户名：")
password = input("请输入密码：")is_success = Falsefor item in user_list:if username == item[0] and password == item[1]:is_success = Truebreakif is_success:print("登录成功")
else:print("登录失败")

6.集合（set）

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

6.1 定义

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

• 无序，无法通过索引取值。

• 可变，可以添加和删除元素。

  data={1,5,2,"xiaofeng"}
  print(data)
  data.add(1.2)
  print(data) 
  

• 不允许数据重复。

  data={1,5,2,"xiaofeng",5}
  print(data)
  

一般什么时候用集合呢？

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

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

v1 = []#空列表
v11 = list()v2 = () #空元组
v22 = tuple()v3 = set() #空集合v4 = {} # 空字典
v44 = dict()

6.2 独有功能

1. 添加元素

   data=set()
   data.add("xiaofeng")
   data.add(2)
   print(data)
   

2. 删除元素

   data=set()
   data.add("xiaofeng")
   data.add(2)
   print(data)
   data.discard("xiaofeng")
   print(data)

3. 交集

   v1={2,6,'xiao','feng'}
   v2={3,6,'feng','zhang'}
   print(v1.intersection(v2))
   print(v1&v2)

4. 并集

   v1={2,6,'xiao','feng'}
   v2={3,6,'feng','zhang'}
   print(v1.union(v2))
   print(v1|v2)

5. 差集

   v1={2,6,'xiao','feng'}
   v2={3,6,'feng','zhang'}
   print(v1.difference(v2))
   print(v1-v2)
   print(v2.difference(v1))
   print(v2-v1)

6.3 公共功能

1. 减，计算差集

   v1={2,6,'xiao','feng'}
   v2={3,6,'feng','zhang'}
   print(v1-v2)
   print(v2-v1)
   

2. &，计算交集

   v1={2,6,'xiao','feng'}
   v2={3,6,'feng','zhang'}
   print(v1&v2)

3. |，计算并集

   v1={2,6,'xiao','feng'}
   v2={3,6,'feng','zhang'}
   print(v1|v2)

4. 长度

   v={2,6,'xiao','feng'}
   print(len(v))

5. for循环

   v={2,6,'xiao','feng'}
   for i in v:print(i,end=' ')

6.4 转换

其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。

提示：int/list/tuple/dict 都可以转换为集合。（str也是可以的，但是比较特殊）

a='xajnxj'
print(set(a))

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)

6.5 其他

6.5.1 集合的存储原理

        通过哈希表的存储方式，Python的集合数据类型实现了高效的查找、插入和删除操作。哈希表存储的特性使得集合的平均时间复杂度为O(1)，因此在需要进行快速查找不重复元素的场景中，集合是很常用的数据结构。

6.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,["xiao","feng"],33]
  v2 = set(v1) # 报错 
  print(v2) 
  

6.5.3 查找速度特别快

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

• 低

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

• 效率高

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

6.5.4 对比和嵌套

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

注意：由于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
v1 = [11,22,33,44]

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

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

0 
"" #空字符串
[] or list()
() or tuple()
set()
None

7.字典（dict)

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

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

• 容器

• 元素必须键值对

• 键不重复，重复则会被覆盖

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

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

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

7.1 定义

v1 = {} #这两种都代表空字典
v2 = dict()

info={"姓名":"xiaofeng","年龄":20,"性别":"男","爱好":["编程","乒乓球"]
}
print(info)

字典中对键值得要求：

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

data_dict = {"小峰":29,True:5,123:5,(11,22,33):["王","zhang"]
}

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

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

# 用户列表
user_list = [ ("admin","123"), ("xiaofeng","666") ]
...

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

7.2 独有功能

1. 获取值

   user_list={"xiaofeng":"xiaofeng","admin":"123456"
   }
   user_name=input("请输入用户名：")
   user_pwd=input("请输入密码：")
   if user_list.get(user_name):while  user_pwd!=user_list.get(user_name):print("密码错误，请重新输入！")user_pwd = input("请输入密码：")else:print("密码正确，登陆成功！")
   else:print("对不起，该用户不存在！")# 但我建议一般遵循写代码的准则：简单的逻辑处理放在前面；复杂的逻辑放在后面。
   

2. 所有的键

   info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
   data=info.keys()
   print(type(data))
   print(list(data))

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

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

3. 所有的值

   info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
   for i in info.values():print(i)

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

4. 所有的键值

   info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
   for i in info.items():print(i)

   info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
   for i in info.items():print(i[0],i[1]) # item是一个元组 (键，值)
   

   info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
   for i,j in info.items():print(i,j) #i代表键，j代表值，将兼职从元组中直接拆分出来了。
   

5. 设置值

   info = {"age":12, "status":True, "name":"xiaofeng"}
   print(info)
   info.setdefault("h",180)
   print(info)
   

6. 更新字典键值对

   info = {"age":12, "status":True, "name":"xiaofeng"}
   print(info)
   info.update({"name":'zhang'})
   print(info)
   

7. 移除指定键值对

   info = {"age":12, "status":True, "name":"xiaofeng"}
   info.pop('age')
   

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

   info = {"age":12, "status":True, "name":"xiaofeng"}
   data=info.popitem()
   print(data)
   print(info)
   

   • py3.6后，popitem移除最后一个位置的值。
   • py3.6之前，popitem随机删除。

# 练习题
""" 
结合下面的两个变量 header 和 stock_dict实现注意输出股票信息，格式如下：SH601778，股票名称:中国晶科、当前价:6.29、涨跌额:+1.92。SH688566，股票名称:吉贝尔、当前价:...               。...
"""
header = ['股票名称', '当前价', '涨跌额']stock_dict = {'SH601778': ['中国晶科', '6.29', '+1.92'], 'SH688566': ['吉贝尔', '52.66', '+6.96'], 'SH688268': ['华特气体', '88.80', '+11.72'], 'SH600734': ['实达集团', '2.60', '+0.24']
}

7.3 公共功能

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

   d1={"k1":1,"k3":3}
   d2={"k3":3,"k4":4}
   print(d1|d2)
   

2. 长度

   d1={"k1":1,"k3":3}
   print(len(d1))

3. 是否包含

   d1={"k1":1,"k3":3}
   print("k1" in d1)
   print("k1" in d1.keys())
   print(1 in d1.values())
   print(("k3",3) in d1.items())

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

   d1={"k1":1,"k3":3}
   print(d1["k1"])
   print(d1.get("k1"))

5. 根据 键 修改值 和 添加值 和 删除键值对 上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作

   d={"k1":3,"k2":2}
   d["k3"]=3 #添加
   print(d)
   d["k1"]=4 #通过键进行更新
   print(d)
   del d["k2"] #通过键进行删除
   print(d)

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

   info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
   for i in info.items():print(i)
   

   info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
   for i in info.keys():print(i) 

   info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
   for i in info.values():print(i) 

   info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
   for i,j in info.items():print(i,j) #i代表键，j代表值，将兼职从元组中直接拆分出来了。

7.4 转换

想要转换为字典.

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

info = { "age":12, "status":True, "name":"xiaofeng" }
v1 = list(info)
v2 = list(info.keys())
#以上这两种是相同的结果 ['age', 'status', 'name']
v3 = list(info.values())
#[12, True, 'xiaofeng']
v4 = list(info.items())
#[('age', 12), ('status', True), ('name', 'xiaofeng')]

7.5 其他

1.5.1 存储原理

        Python的字典通过哈希函数和哈希表的结构，实现了高效的键值对存储和查找，平均情况下字典操作的时间复杂度为O(1)，即具有很高的性能。

1.5.2 速度快

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 时，需注意重复的情况。

• PS:元组的元素不可以被替换。

8.浮点型（float）

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

v1 = 3.14
v2 = 9.89

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

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

  print(int(3.14))

• 想要保留小数点后N位

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

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

  print(0.1+0.2)  #0.30000000000000004

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

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

  import decimalv1 = decimal.Decimal("0.1")
  v2 = decimal.Decimal("0.2")
  v3 = v1 + v2
  print(v3) # 0.3
  #为什么普通浮点数计算 0.1 + 0.2 不精确？‌
  ‌二进制浮点数的局限性‌：
  Python 的 float 类型基于 IEEE 754 标准，用二进制表示小数。
  0.1 和 0.2 在二进制中是无限循环小数（类似 1/3 在十进制中的情况），导致存储时被截断，引发精度丢失。
  ‌十进制算术‌：
  decimal.Decimal 直接以十进制格式存储和计算数值，避免了二进制浮点的截断误差。
  ‌精确表示‌：
  使用字符串初始化（如 Decimal("0.1")）确保值在构造时无精度损失。
  （若用 Decimal(0.1) 会传递浮点数的近似值，仍然不精确！

 本   篇   完   结   …  …

---

持     续     更     新     中   …    …