Python基础——常见数据类型总结

在Python中常见的数据类型有以下8个类型，分别是：int，整数类型（整形）、float，浮点类型（浮点型）、bool，布尔类型、str，字符串类型、list，列表类型、tuple，元组类型、dict，字典类型、set，集合类型。接下来一一展开介绍。

1、int，整数类型（整形）

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

1.1 定义

number = 10
age = 99

1.2  转换

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

# 布尔值转整型
n1 = int(True) # True转换为整数 1
n2 = int(False) # False转换为整数 0
# 字符串转整型
v1 = int("186",base=10) # 把字符串看成十进制的值，然后再转换为 十进制整数，结果：v1 = 186
v2 = int("0b1001",base=2) # 把字符串看成二进制的值，然后再转换为 十进制整数，结果：v1 = 9
(0b表示二进制)
v3 = int("0o144",base=8) # 把字符串看成八进制的值，然后转换为 十进制整数，结果：v1 = 100
(0o表示八进制)
v4 = int("0x59",base=16) # 把字符串看成十六进制的值，然后转换为 十进制整数，结果：v1 = 89
（0x表示十六进制）
# 浮点型（小数）
v1 = int(8.7) # 8

1.3 版本之间的不同

长整型

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

地板除 

py3：print(9/2)  # 4.5

py2：print(9/2)  # 4     （如果 需要正常计算可以加from __future__ import division）

2、float，浮点类型（浮点型）

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

2.1 定义

v1 = 3.14
v2 = 9.89

2.2 转换

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

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

想要保留小数点后N位

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

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

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

3、bool，布尔类型

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

3.1 定义：

flag = False
hqss = True

3.2 转换

在以后的项目开发中，会经常使用其他类型转换为布尔值的情景，此处只要记住一个规律即可。

整数0、空字符串、空列表、空元组、空字典转换为布尔值时均为False
其他均为True

v1 = bool(0)
v2 = bool(-10)
v3 = bool(10)
v4 = bool("HQSS")
v5 = bool("")
v6 = bool(" ")
v7 = bool([]) # [] 表示空列表
v8 = bool([11，22，33]) # [11，22，33] 表示非空列表
v9 = bool({}) # {} 表示空字典
v10 = bool({"name":"HQSS","age":18}) # {"name":"HQSS","age":18} 表示非空字典
print(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) # Flase, Ture, Ture, Ture, Flase, Ture, Flase, Ture, Flase, Ture

3.3 其他

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

if 值:
    pass

while 值:
    pass

4、str，字符串类型

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

4.1 定义

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

4.2 常用功能函数

data = "你好我是一个字符串"
print( data.startswith("你") )  # 判断字符串是否以 XX 开头？得到一个布尔值
print( data.endswith("串") )    # 判断字符串是否以 XX 结尾？得到一个布尔值

data = "1238871"
print( data.isdecimal() )       # 判断字符串是否为十进制数？得到一个布尔值

data = "  你好, 我是一个字符串  "
print( data.strip() )          # 去除字符串两边的 空格、换行符、制表符，得到一个新字符串
print( data.strip("你") )       # 去除字符串两边指定的内容


data = "my name is hqss"
print( data .upper() )          # 字符串变大写，得到一个新字符串

data = "My Name Is HQSS"
print( data .lower() )          # 字符串变小写，得到一个新字符串

data = "你好我是一个字符串"
print( data.replace("字符串","***") )    # 字符串内容替换，得到一个新的字符串

data = "你好，我是一个，字符串"
print( data.split('，')  )               # 字符串切割，得到一个列表
print( data.split("，", 2)  )            # 按照指定个数切割
print( data.rsplit(',')    )             # 从右边开始切割

data_list = ["我","是","字符串"]
data = "_".join(data_list)       
print( data )                  # 字符串拼接，得到一个新的字符串

# 字符串转换为字节类型
data = "字符串"
print( data.encode("utf-8") )  #  utf-8，字节类型 # b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'
print( data.encode("gbk")  )   #  gbk，字节类型   # b'\xd7\xd6\xb7\xfb\xb4\xae'

# 字节串转换为字符类型
data1 = b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'
data2 = b'\xd7\xd6\xb7\xfb\xb4\xae'
print( data.decode("utf-8") )     #字符串
print( data.decode("gbk") )       #字符串


# 将字符串内容居中、居左、居右展示
data = "HQSS"
print( data.center(21, "-") )      # '---------HQSS--------'
print( data.ljust(21, "-")  )      # 'HQSS-----------------'
print( data.rjust(21, "-")  )      # '-----------------HQSS'


# 帮助填充0
data = "101"              # "00000101"
print( data.zfill(8) )            # "00000101"


# 相加：字符串 + 字符串
data = "我是" + "字符串"   # 我是字符串

# 相乘：字符串 * 整数
data = "HQSS" * 3         
print( data )             # HQSSHQSSHQSS

# 长度
data = "字符串"
print( len(data) )  # 3


# 获取字符串中的字符，索引
data = "我是字符串"
print( data[0] ）   # "我"
print( data[1] )    # "是"
print( data[2] )    # "字"

print( data[-1] )   # "串"
print( data[-2] )   # "符"
print( data[-3] )   # "字"

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

# 获取字符串中的子序列，切片
data = "我是字符串"
print( data[0:2] ）         # "我是"
print( data[2:4] ）         # "字符"
print( data[2:]  ）         # "字符串"
print( data[:3]  ）         # "我是字"
print( data[2:-1] ）        # "字符串"
print( data[2:-2] ）        # "字符"
print( data[2:len(data)] ） # "字符串"

# 注意：字符串中的切片只能读取数据，无法修改数据。【字符串在内部存储时不允许对内部元素修
改，想要修改只能重新创建】

# 步长，跳着查找字符串的内容

data= "生活不是电影，生活比电影苦"
print( data[ 0:5:2 ] ) # 输出：生不电 【前两个值表示区间范围，最有一个值表示步长】
print( data[ :8:2 ] ) # 输出：生不电， 【区间范围的前面不写则表示起始范围为0开始】
print( data[ 2::3 ] ) # 输出：不电，活电苦 【区间范围的后面不写则表示结束范围为最
后】
print( data[ ::2 ] ) # 输出：生不电，活电苦 【区间范围不写表示整个字符串】
print( data[ 8:1:-1 ] ) # 输出：活生，影电是不 【倒序】

4.3 转换

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

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

字符串不可被修改

5、list，列表类型

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

5.1 定义

user_list = ["python","csdn","hqss"]
number_list = [98,88,666,12,-1]
data_list = [1,True,"hqss","宝强","贾乃亮"]
user_list = []
user_list = list()

5.2 列表常用功能函数

## 追加，在原列表中尾部追加值。
data_list = []
data_list.append("hqss")
data_list.append("python")
print(data_list)        # ["hqss", "python"]


## 批量追加，将一个列表中的元素逐一添加另外一个列表。
tools = ["搬砖","菜刀","榔头"]
tools.extend( [11,22,33] ) # weapon中的值逐一追加到tools中
print(tools) # ["搬砖","菜刀","榔头",11,22,33]


## 插入，在原列表的指定索引位置插入值
user_list = ["搬砖","菜刀","榔头"]
user_list.insert(0,"hqss")
user_list.insert(2,"csdn")
print(user_list)     # ["hqss", "搬砖", "csdn", "菜刀", "榔头"]


## 在原列表中根据值删除（从左到右找到第一个删除）【慎用，里面没有会报错】
user_list = ["王宝强","陈羽凡","Hqss","贾乃亮","Hqss"]
user_list.remove("Hqss")
print(user_list)


## 在原列表中根据索引踢出某个元素（根据索引位置删除）
user_list = ["王宝强","陈羽凡","Hqss","贾乃亮","Hqss"]
              # 0       1        2      3       4
user_list.pop(1)
print(user_list) # ["王宝强","Hqss","贾乃亮","Hqss"]

user_list.pop()
print(user_list) # ["王宝强","Hqss","贾乃亮"]

item = user_list.pop(1)
print(item) # "Hqss"
print(user_list) # ["王宝强","贾乃亮"]


## 清空原列表
user_list = ["王宝强","陈羽凡","Hqss","贾乃亮","Hqss"]
user_list.clear()
print(user_list) # []


## 根据值获取索引（从左到右找到第一个删除）【慎用，找不到报错】
user_list = ["王宝强","陈羽凡","Hqss","贾乃亮","Hqss"]
              # 0       1        2      3       4
if "Alex" in user_list:
    index = user_list.index("Hqss")
    print(index) # 2
else:
    print("不存在")


## 列表元素排序
# 数字排序
num_list = [11, 22, 4, 5, 11, 99, 88]
print(num_list)
num_list.sort() # 让num_list从小到大排序
num_list.sort(reverse=True) # # 让num_list从大到小排序
print(num_list)

# 字符串排序
user_list = ["王宝强", "Ab陈羽凡", "Alex", "贾乃亮", "贾乃", "1"]
#           [29579, 23453, 24378]
#           [65, 98, 38472, 32701, 20961]
#           [65, 108, 101, 120]
#           [49]
print(user_list)
"""
sort的排序原理
[ "x x x" ," x x x x x " ]
"""
user_list.sort()
print(user_list)

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


## 反转原列表
user_list = ["王宝强","陈羽凡","Hqss","贾乃亮","Hqss"]
user_list.reverse()
print(user_list)


## 相加，两个列表相加获取生成一个新的列表。
data = ["赵四","刘能"] + ["宋晓峰","范德彪"]
print(data) # ["赵四","刘能","宋晓峰","范德彪"]


## 相乘，列表*整型 将列表中的元素再创建N份并生成一个新的列表。
data = ["赵四","刘能"] * 2
print(data) # ["赵四","刘能","赵四","刘能"]


## 运算符in包含, 由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中。
user_list = ["狗子","二蛋","沙雕","hqss"]
if "hqss" in user_list:
    print("在，把他删除")
    user_list.remove("hqss")
else:
    print("不在")

# 注意：列表检查元素是否存在时，是采用逐一比较的方式，效率会比较低。


## 获取长度
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( len(user_list) )


## 索引，一个元素的操作
# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( user_list[0] )
print( user_list[2] )
print( user_list[3] ) # 报错

# 改
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
user_list[0] = "武沛齐"
print(user_list) # ["武沛齐","刘华强",'尼古拉斯赵四']

# 删
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
del user_list[1]
user_list.remove("刘华强")
ele = user_list.pop(1)

# 注意：超出索引范围会报错。
# 提示：由于字符串是不可变类型，所以他只有索引读的功能，而列表可以进行 读、改、删


## 切片，多个元素的操作（很少用）

# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( user_list[0:2] ) # ["范德彪","刘华强"]
print( user_list[1:] )
print( user_list[:-1] )

# 改
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[0:2] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '尼古拉斯赵四']

# 删
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:]
print(user_list) # 输出 ['范德彪']


## 步长
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
# 0 1 2 3 4
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )

# 案例：实现列表的翻转
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
new_data = user_list[::-1]
print(new_data)

data_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data_list.reverse()
print(data_list)


## for循环
# 切记，循环的过程中对数据进行删除会踩坑【面试题】。

# 错误方式， 有坑，结果不是你想要的。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for item in user_list:
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)

# 正确方式，倒着删除。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for index in range(len(user_list) - 1, -1, -1):
    item = user_list[index]
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)

5.3 转换

int、bool无法转换成列表

# 字符串转列表
name = "HQSS"
data = list(name) # ["H","Q","S","S"]


#元组转列表
v1 = (11,22,33,44) # 元组
vv1 = list(v1) # 列表 [11,22,33,44]


# 字典转列表
v2 = {"alex","eric","dsb"} # 集合
vv2 = list(v2) # 列表 ["alex","eric","dsb"]

5.4 嵌套

列表属于容器，内部可以存放各种数据，所以他也支持列表的嵌套，如：

data = [ "谢广坤",["海燕","赵本山"],True,[11,22,[999,123],33,44],"宋小宝" ]

6、tuple，元组类型

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

6.1 定义

v1 = (11,22,33)
v2 = ("李杰","Hqss")
v3 = (True,123,"Hqss",[11,22,33,44])
# 建议：议在元组的最后多加一个逗v3 = ("李杰","Hqss",)

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

# 面试题
1. 比较值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别？
   v1和v2是整形，v3是元组

2. 比较值 v1 = ( (1),(2),(3) ) 和 v2 = ( (1,) , (2,) , (3,),) 有什么区别？
   v1内的元素为整形，v2内的元素为元组

6.2  元组常用功能

## 相加，两个列表相加获取生成一个新的列表。
data = ("赵四","刘能") + ("宋晓峰","范德彪")
print(data) # ("赵四","刘能","宋晓峰","范德彪")


## 相乘，列表*整型 将列表中的元素再创建N份并生成一个新的列表。
data = ("赵四","刘能") * 2
print(data) # ("赵四","刘能","赵四","刘能")


## 获取长度
user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print(len(user_list))


## 索引
user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0] )
print( user_list[2] )
print( user_list[3] )


## 切片
user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0:2] )
print( user_list[1:] )
print( user_list[:-1] )


## 步长
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )

# 字符串 & 元组。
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
data = user_list[::-1]

# 列表
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data = user_list[::-1]
user_list.reverse()
print(user_list)


## for循环
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for item in user_list:
print(item)

# 目前：只有 str、list、tuple 可以被for循环。

6.3 转换

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

data = tuple(其他)


# 字符串转元组
name = "HQSS"
data = tuple(name)
print(data) # 输出 ("H","Q","S","S")


# 列表转元组
name = ["HQSS",18,"pythonav"]
data = tuple(name)
print(data) # 输出 ("HQSS",18,"pythonav")

6.4 嵌套

由于元组和列表都可以充当容器，他们内部可以放很多元素，并且也支持元素内的各种嵌套。

data = ["alex", [11,22,(88,99,100,),33], "WuSir", ("ritian", "barry",), "wenzhou"]

记住一句话：《"我儿子永远不能换成是别人，但我儿子可以长大"》

7、set，集合类型

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

7.1 定义

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

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

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

• 不允许数据重复

一般什么时候用集合呢？

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

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

7.2 集合常用功能

## 添加元素

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

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


## 删除元素

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


## 交集

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


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


## 差集
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)


## 减，计算差集
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 - s2
s4 = s2 - s1
print(s3)
print(s4)


## &，计算交集
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 & s2
print(s3)


## |，计算并集
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 | s2
print(s3)


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


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

7.3转换 

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

提示：int/list/tuple/dict都可以转换为集合。

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

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

7.4 其他

集合的储存原理：

元素必须可哈希

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

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

总结：集合的元素只能是 int、bool、str、tuple 。

查找速度特别快

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

对比和嵌套

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
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}

8、dict，字典类型

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

• 容器

• 元素必须键值对

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

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

8.1  定义

v1 = {}
v2 = dict()

字典中对键值得要求：

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

• 值：任意类型

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

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

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

8.2 字典常用功能

## 获取值

info = { 
    "age":12, 
    "status":True, 
    "name":"HQSS",
    "data":None
}

data1 = info.get("name")
print(data1) # 输出：HQSS

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

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


# 所有的键
info = {"age":12, "status":True, "name":"HQSS","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":"HQSS","email":"xx@live.com"}
data = info.values()
print(data) # 输出：dict_values([12, True, 'HQSS', 'xx@live.com'])

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


## 所有的键值
info = {"age":12, "status":True, "name":"HQSS","email":"xx@live.com"}
data = info.items()
print(data) # 输出 dict_items([ ('age', 12),  ('status', True),  ('name', 'HQSS'),  ('email', 'xx@live.com')  ])


## 设置值
data = {
    "name": "HQSS",
    "email": 'xxx@live.com'
}
data.setdefault("age", 18)
print(data)  # {'name': 'HQSS', 'email': 'xxx@live.com', 'age': 18}


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


## 移除指定键值对
info = {"age":12, "status":True,"name":"HQSS"}
data = info.pop("age")
print(info) # {"status":True,"name":"HQSS"}
print(data) # 12


## 按照顺序移除（后进先出）
info = {"age":12, "status":True,"name":"HQSS"}
data = info.popitem() # ("name","HQSS" )
print(info) # {"age":12, "status":True}
print(data) # ("name","HQSS")


## 求`并集`（Python3.9新加入）
v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}

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


## 长度
info = {"age":12, "status":True,"name":"HQSS"}
data = len(info)
print(data) # 输出：3


## 是否包含
info = { "age":12,  "status":True,"name":"HQSS" }
v1 = "age" in info
print(v1)


## 索引（键）
字典不同于元组和列表，字典的索引是`键`，而列表和元组则是 `0、1、2等数值` 。
info = { "age":12,  "status":True, "name":"HQSS"}

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

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


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

# 修改
info = {"age":12, "status":True,"name":"HQSS"}
info["gender"] = "男"
print(info) # 输出： {"age":12, "status":True,"name":"HQSS","gender":"男"}

# 添加
info = {"age":12, "status":True,"name":"HQSS"}
info["age"] = "18" 
print(info) # 输出： {"age":"18", "status":True,"name":"HQSS"}

# 删除
info = {"age":12, "status":True,"name":"HQSS"}
del info["age"]  # 删除info字典中键为age的那个键值对（键不存在则报错）
print(info) # 输出： {"status":True,"name":"HQSS"}


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

8.3 转换

转换为字典

v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )
print(v)                 # { "k1":"v1", "k2":"v2" }

info = { "age":12, "status":True, "name":"HQSS" }
v1 = list(info)          # ["age","status","name"]
v2 = list(info.keys())   # ["age","status","name"]
v3 = list(info.values()) # [12,True,"HQSS"]
v4 = list(info.items())  # [ ("age",12), ("status",True), ("name","HQSS") ]

8.4 其他

存储原理

速度快

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

嵌套

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

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

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

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

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

至此，常见的八大数据类型都已总结完毕，如有不当之处，请大家多多指正。