Python数据类型进阶——详解

------ 小峰编程

1.整型

[1.1 定义](#1.1 定义)

[1.2 独有功能](#1.2 独有功能)

[1.3 公共功能](#1.3 公共功能)

[1.4 转换](#1.4 转换)

[1.5 其他](#1.5 其他)

[1.5.1 长整型](#1.5.1 长整型)

[1.5.2 地板除(除法）](#1.5.2 地板除(除法）)

[2. 布尔类型](#2. 布尔类型)

[2.1 定义](#2.1 定义)

[2.2 独有功能](#2.2 独有功能)

[2.3 公共功能](#2.3 公共功能)

[2.4 转换](#2.4 转换)

[2.5 其他](#2.5 其他)

做条件自动转换

3.字符串类型

[3.1 定义](#3.1 定义)

[3.2 独有功能（18/48）](#3.2 独有功能（18/48）)

[3.3 公共功能](#3.3 公共功能)

[3.4 转换](#3.4 转换)

[3.5 其他](#3.5 其他)

4.列表（list）

[1.1 定义](#1.1 定义)

[1.2 独有功能](#1.2 独有功能)

[1.3 公共功能](#1.3 公共功能)

5.元组

[5.1 定义](#5.1 定义)

[5.2 独有功能](#5.2 独有功能)

[5.3 公共功能](#5.3 公共功能)

[5.4 转换](#5.4 转换)

[5.5 其他](#5.5 其他)

嵌套

6.集合（set）

[6.1 定义](#6.1 定义)

[6.2 独有功能](#6.2 独有功能)

[6.3 公共功能](#6.3 公共功能)

[6.4 转换](#6.4 转换)

[6.5 其他](#6.5 其他)

[6.5.1 集合的存储原理](#6.5.1 集合的存储原理)

[6.5.2 元素必须可哈希](#6.5.2 元素必须可哈希)

[6.5.3 查找速度特别快](#6.5.3 查找速度特别快)

[6.5.4 对比和嵌套](#6.5.4 对比和嵌套)

补充：None类型

7.字典（dict))

[7.1 定义](#7.1 定义)

[7.2 独有功能](#7.2 独有功能)

[7.3 公共功能](#7.3 公共功能)

[7.4 转换](#7.4 转换)

[7.5 其他](#7.5 其他)

[1.5.1 存储原理](#1.5.1 存储原理)

[1.5.2 速度快](#1.5.2 速度快)

[1.5.3 嵌套](#1.5.3 嵌套)

8.浮点型（float）

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

int，整数类型（整形）

bool，布尔类型

str，字符串类型

list，列表类型

tuple，元组类型

dict，字典类型

set，集合类型

float，浮点类型（浮点型）

1.整型

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

1.1 定义

python 复制代码

number = 10
age = 99

1.2 独有功能

python 复制代码

# 调用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 公共功能

加减乘除

python 复制代码

v1 = 4
v2 = 8
v3 = v1 + v2

1.4 转换

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

python 复制代码

# 布尔值转整型
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：
python 复制代码
```
v1 = 9/2 
print(v1) # 4.5
```
py2:
python 复制代码
```
v1 = 9/2 
print(v1) # 4
```

2. 布尔类型

布尔值，其实就是 "真"、"假" 。

2.1 定义

python 复制代码

a = False
b = True

2.2 独有功能

2.3 公共功能

python 复制代码

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

2.4 转换

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

python 复制代码

# 练习题：查看一些变量为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 条件后面写一个值当做条件时，他会默认转换为布尔类型，然后再做条件判断。

python 复制代码

if 0:
	print("太六了")
else:
  print(999)

if "武齐":
	print("你好")

if "alex":
	print("你是王？")
else:
	print("你是李？")

python 复制代码

while 1<9:
  pass

python 复制代码

if 值:
  pass

while 值:
  pass

3.字符串类型

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

3.1 定义

python 复制代码

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

3.2 独有功能（18/48）

python 复制代码

"xxxxx".功能(...)

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

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

python 复制代码

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

python 复制代码

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

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

python 复制代码

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

python 复制代码

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

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

python 复制代码

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

python 复制代码

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

python 复制代码

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

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

python 复制代码

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

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

python 复制代码

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

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

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

python 复制代码

# 案例
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"
"""

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

python 复制代码

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

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

python 复制代码

# 案例
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)

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

python 复制代码

# 案例：判断用户名密码是否正确
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("用户名或密码错误")

扩展

python 复制代码

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

应用场景：

python 复制代码

#经常用于对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]

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

python 复制代码

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

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

python 复制代码

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

字符串转换为字节类型

python 复制代码

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)

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

python 复制代码

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

帮助你填充0

python 复制代码

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

3.3 公共功能

相加：字符串 + 字符串
python 复制代码
```
print("xiao"+"feng")
```
相乘：字符串 * 整数
python 复制代码
```
print( "xiaofeng" * 3)
```

长度

python 复制代码

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

获取字符串中的字符，索引
python 复制代码
```
a="来这里吃点东西"
   0 1 2 3 4 5 6
  -7   ...    -1
print(a[0])
print(a[-1])
```
**注意：**字符串中是能通过索引取值，无法修改值。【字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。】

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

python 复制代码

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])#相当于字符串逆置/倒序

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

python 复制代码

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

循环

while循环

python 复制代码

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

for循环

python 复制代码

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

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

python 复制代码

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

python 复制代码

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

python 复制代码

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

一般应用场景：

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

python 复制代码

while True:
    ...

python 复制代码

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

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

python 复制代码

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

python 复制代码

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

break和continue关键字

python 复制代码

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

python 复制代码

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

3.4 转换

python 复制代码

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

python 复制代码

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

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

3.5 其他

字符串不可被修改

python 复制代码

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

4.列表（list）

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

1.1 定义

python 复制代码

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

python 复制代码

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

补充：

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

可变类型：列表（内部数据元素可以修改）

1.2 独有功能

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

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

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

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

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

python 复制代码

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

python 复制代码

welcome="欢迎来到游戏".center(30,"*")
print(welcome)
user_count=0
while True:
    user_count=input("请输入玩游戏的人数：")
    if user_count.isdecimal():
        user_count=int(user_count)
        break
    else:
        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)

批量追加，将一个列表中的元素逐一添加另外一个列表。
python 复制代码
```
data = ['xiaoli',20,'男']
data.extend(['xiaowang',23,'女'])
print(data)
```

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

python 复制代码

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

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

python 复制代码

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

python 复制代码

# 案例：自动抽奖程序
import random

data_list = ["iphone12", "购物卡", "洗手液", "泰国5日游"]

while data_list:
    name = input("自动抽奖程序，请输入自己的姓名：")

    # 随机从data_list抽取一个值出来
    value = random.choice(data_list) 
    print( "恭喜{}，抽中{}.".format(name, value) )
    
    data_list.remove(value)

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

python 复制代码

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","贾乃亮"]

python 复制代码

# 案例：排队买火车票
user_queue=[]
ticket=5
while True:
    name=input("请输入你的名字进行排队购买(Q退出)：")
    if name=="Q":
        break
    else:
       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}.")

清空原列表

python 复制代码

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

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

python 复制代码

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

列表元素排序

python 复制代码

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

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

反转原列表

python 复制代码

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

1.3 公共功能

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

python 复制代码

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

相乘，列表*整型将列表中的元素再创建N份并生成一个新的列表。
python 复制代码
```
data = ["赵四","刘能"] * 2
print(data) # ["赵四","刘能","赵四","刘能"]
```
运算符in包含由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中。
python 复制代码
```
user_list = ["小王","雪","xiaofeng","雪"]
result = "xiaofeng" in user_list
print(result)
```

5.元组

5.1 定义

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

python 复制代码

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

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

python 复制代码

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

5.2 独有功能

无

5.3 公共功能

相加，两个列表相加获取生成一个新的列表。
python 复制代码
```
print((1,4)+(2,5))
```
相乘，列表*整型将列表中的元素再创建N份并生成一个新的列表。
python 复制代码
```
print((1,3)*2)
```
获取长度
python 复制代码
```
data=('xiao',3,6)
print(len(data))
```
索引
python 复制代码
```
data=('xiao',3,6)
print(data[1])
```

切片

python 复制代码

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

步长

python 复制代码

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

for循环

python 复制代码

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

python 复制代码

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

5.4 转换

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

python 复制代码

data = tuple(其他)

python 复制代码

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

python 复制代码

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

5.5 其他

嵌套

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

python 复制代码

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)

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

python 复制代码

# 创建用户 5个
# user_list = [] # 用户信息
while True:
    user = input("请输入用户名：")
    if user == "Q":
        brek
    pwd = input("请输入密码：")
    item = (user,pwd,)
    user_list.append(item)
    
# 实现：用户登录案例
print("登录程序")
username = input("请输入用户名：")
password = input("请输入密码：")

is_success = False

for item in user_list:
    if username == item[0] and password == item[1]:
        is_success = True
        break

if is_success:
    print("登录成功")
else:
    print("登录失败")

6.集合（set）

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

6.1 定义

python 复制代码

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

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

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

python 复制代码

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

不允许数据重复。
python 复制代码
```
data={1,5,2,"xiaofeng",5}
print(data)
```

一般什么时候用集合呢？

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

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

python 复制代码

v1 = []#空列表
v11 = list()

v2 = () #空元组
v22 = tuple()

v3 = set() #空集合

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

6.2 独有功能

添加元素

python 复制代码

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

删除元素

python 复制代码

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

交集

python 复制代码

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

并集

python 复制代码

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

差集

python 复制代码

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 公共功能

减，计算差集

python 复制代码

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

&，计算交集

python 复制代码

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

|，计算并集

python 复制代码

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

长度
python 复制代码
```
v={2,6,'xiao','feng'}
print(len(v))
```

for循环

python 复制代码

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

6.4 转换

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

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

python 复制代码

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

python 复制代码

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

python 复制代码

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

提示：这其实也是去重的一个手段。

python 复制代码

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 。
转换成功
python 复制代码
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
转换失败
python 复制代码
v1 = [11,22,["xiao","feng"],33]
v2 = set(v1) # 报错 
print(v2) 

6.5.3 查找速度特别快

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

低

python 复制代码

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

效率高

python 复制代码

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出现在集合中会有如下现象：

python 复制代码

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作用一样。在一定程度上可以帮助我们去节省内存。例如：
python 复制代码
v1 = None
v1 = [11,22,33,44]
**注意：**暂不要考虑Python内部的缓存和驻留机制。

目前所有转换为布尔值为False的值有：
python 复制代码
0 
"" #空字符串
[] or list()
() or tuple()
set()
None

7.字典（dict)

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

python 复制代码

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

容器

元素必须键值对
键不重复，重复则会被覆盖
python 复制代码
data = { "k1":1, "k1":2 }
print(data) # {"k1":2}
无序（在Python3.6+字典就是有序了，之前的字典都是无序。）
python 复制代码
data = { "k1":1,  "k2":2 }
print(data)

7.1 定义

python 复制代码

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

python 复制代码

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

字典中对键值得要求：

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

值：任意类型。

python 复制代码

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

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

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

python 复制代码

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

python 复制代码

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

7.2 独有功能

获取值

python 复制代码

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("对不起，该用户不存在！")
        
# 但我建议一般遵循写代码的准则：简单的逻辑处理放在前面；复杂的逻辑放在后面。

所有的键

python 复制代码

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

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

python 复制代码

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

所有的值
python 复制代码
```
info = {"age":12, "status":True, "name":"xiaofeng","email":"@xiaofeng.com"}
for i in info.values():
    print(i)
```
注意： 在Python2中字典.values()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。

所有的键值

python 复制代码

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

python 复制代码

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

python 复制代码

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

设置值

python 复制代码

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

更新字典键值对

python 复制代码

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

移除指定键值对

python 复制代码

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

按照顺序移除（后进先出）
python 复制代码
```
info = {"age":12, "status":True, "name":"xiaofeng"}
data=info.popitem()
print(data)
print(info)
```
- py3.6后，popitem移除最后一个位置的值。
- py3.6之前，popitem随机删除。

python 复制代码

# 练习题
""" 
结合下面的两个变量 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 公共功能

求并集（Python3.9新加入）
python 复制代码
```
d1={"k1":1,"k3":3}
d2={"k3":3,"k4":4}
print(d1|d2)
```
长度
python 复制代码
```
d1={"k1":1,"k3":3}
print(len(d1))
```

是否包含

python 复制代码

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())

索引（键）字典不同于元组和列表，字典的索引是键，而列表和元组则是 0、1、2等数值 。
python 复制代码
```
d1={"k1":1,"k3":3}
print(d1["k1"])
print(d1.get("k1"))
```
根据键 修改值 和 添加值 和 删除键值对 上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作
python 复制代码
```
d={"k1":3,"k2":2}
d["k3"]=3 #添加
print(d)
d["k1"]=4 #通过键进行更新
print(d)
del d["k2"] #通过键进行删除
print(d)
```

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

python 复制代码

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

python 复制代码

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

python 复制代码

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

python 复制代码

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

7.4 转换

想要转换为字典.

python 复制代码

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

python 复制代码

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不可哈希）。
python 复制代码
info = {
    (11,22):123
}
# 错误
info = {
    (11,[11,22,],22):"alex"
}
字典的值可以是任意类型。
python 复制代码
info = {
    "k1":{12,3,5},
	"k2":{"xx":"x1"}
}
字典的键和集合的元素在遇到布尔值和 1、0 时，需注意重复的情况。

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

8.浮点型（float）

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

python 复制代码

v1 = 3.14
v2 = 9.89

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

在类型转换时需要，在浮点型转换为整型时，会将小数部分去掉。
python 复制代码
```
print(int(3.14))
```

想要保留小数点后N位

python 复制代码

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

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

python 复制代码

print(0.1+0.2)  #0.30000000000000004

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

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

python 复制代码

import decimal

v1 = 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) 会传递浮点数的近似值，仍然不精确！

本篇完结 ... ...

持续更新中 ... ...