python数据类型之字典、元组

一、字典

1、定义字典

字典是 有序（3.6+以前无序）、键不重复 且 元素只能是键值对的可变的 个 容器。键不重复，重复则会被覆盖

如下定义一个字典

# 使用大括号 {} 来创建空字典
test_dic1 = {}
# 使用内建函数 dict() 创建字典：
test_dic2 = dict()
# 创建有值得字典
info = {
    "age": 12,
    "status": True,
    "name": "测试",
    "hobby": ['篮球', '足球'],
    (11, 22, 33): ["alex", "eric"],
    True: 5,
    12: 10
}

# 打印字典
print(info)  # {'age': 12, 'status': True, 'name': '测试', 'hobby': ['篮球', '足球'], (11, 22, 33): ['alex', 'eric'], True: 5, 12: 10}
# 查看字典大小
print(len(info))  # 7
# 字典类型
print(type(info))  # <class 'dict'>

字典中对键值得要求：

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

如下的字典是不合法的

# 不合法
v1 = {
    [1, 2, 3]: '周杰伦',
    "age" : 18
} 
v2 = {
    {1,2,3}: "哈哈哈",
    'name':"alex"
} 

v3 = {
    {"k1":123,"k2":456}: '呵呵呵',
    "age":999
}

 注意：字典里 如何一个key是1或0，另一个是True或False,会替换掉，如下 

test = {1: 5, True: 6}
print(test)  # 打印结果是{1: 6}

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

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

# 用户列表
user_list = [ ("alex","123"), ("admin","666") ]
# 用户列表 字典表示
user_list = [ {"name":"alex","pwd":"123"}, {"name":"eric","pwd":"123"} ]

2、获取字典值

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}

# 获取值
name = info.get("name")
email = info.get("email")  # 如果键不存在返回 None
data = info.get("data")  # 注意:如果值是None 返回结果就是值None

if name:
    print("键name存在，值是", name)  # 打印
if email:
    print("键email存在，值是", email)  # 不打印
if data:
    print("键data存在，值是", data)  # 不打印

3、所有键

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}

# 所有键
keys = info.keys()
print(keys)

'''
python3输出 dict_keys(['age', 'status', 'name', 'data'])
但是python2输出['age', 'status', 'name', 'data']
Python3中返回的是高仿列表，这个高仿的列表可以被循环显示
'''
# 循环
for ele in info.keys():
    print(ele)
# 当然也可以通过list将高仿的列表转成列表
result = list(keys)
print(result)  # ['age', 'status', 'name', 'data']

# 获取所有键 也可以直接用for循环
for item in info:
    print(item)

4、是否存在键

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}

# 是否存在键
# 方式1（推荐）
if "name" in info:
    print("info存在键name")
# 方式2
if "name" in info.keys():
    print("info存在键name")

5、所有值

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}

# 所有值
values = info.values()
print(values)
'''
python3输出 dict_values([12, 0, '测试', None])
python2输出 [12, 0, '测试', None]
python3输出高仿列表这个高仿的列表可以被循环显示
'''
# 循环
for v in values:
    print(v)

# 当然通过list可以将高仿列表转成列表
value1 = list(values)
print(value1)

6、是否存在值

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}

# 是否存在值
if "测试" in info.values():
    print("info 存在值 测试")

7、所有键值对

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}

# 所有的键值
item1 = info.items()
print(item1)  # dict_items([('age', 12), ('status', 0), ('name', '测试'), ('data', None)])

for item in info.items():
    print(item[0], item[1])  # item是一个元组 (键，值)

for key, value in info.items():
    print(key, value)  # key代表键，value代表值，将键和值从元组中直接拆分出来了。

8、是否存在键值对

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}
# 是否存在键值
if ('age', 12) in info.items():
    print("在")
else:
    print("不在")

9、设置值

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}
# 设置值
info.setdefault("email", "[email protected]")
print(info)  # {'age': 12, 'status': 0, 'name': '测试', 'data': None, 'email': '[email protected]'}

info.setdefault("name", "test")  # 如果键存在 则不设置
print(info)  # {'age': 12, 'status': 0, 'name': '测试', 'data': None, 'email': '[email protected]'}

10、更新键值对

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}
# 更新值
info.update({"age": 14, "name": "test"})  # info中没有的键直接添加；有的键则更新值
print(info)  # {'age': 14, 'status': 0, 'name': 'test', 'data': None}

11、移除指定键值对

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}
# 移除指定键值对
info.pop("age")
print(info)  # {'status': 0, 'name': '测试', 'data': None}

12、按照顺序移除（后进先出）

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}
# 按顺序移除
data = info.popitem()
print(info)  # {'age': 12, 'status': 0, 'name': '测试'}
print(data)  # ('data', None) 被移除的被自动转成了一个元祖

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

13、求并集

（Python3.9新加入）

v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}

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

14、索引（键）

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

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}

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

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

15、根据索引键 修改值 和 添加值 和 删除键值对

上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作 

info = {
    "age": 12,
    "status": 0,
    "name": "测试",
    "data": None
}

# 增加键值对
info["gender"] = "男"
print(info)  # {'age': 12, 'status': 0, 'name': '测试', 'data': None, 'gender': '男'}

# 更新键值对
info["age"] = 18
print(info)  # {'age': 18, 'status': 0, 'name': '测试', 'data': None, 'gender': '男'}

# 删除键值对
del info["age"]  # 删除info字典中键为age的那个键值对（键不存在则报错）
print(info)  # 输出： {'status': 0, 'name': '测试', 'data': None, 'gender': '男'}

16、转换

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

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

17、嵌套

# 字典的键必须可哈希（list/set/dict不可哈希）
info = {
    (11, 22): 123
}

# 错误
info = {
    (11, [11, 22, ], 22): "alex"
}

# 字典的值可以是任意类型
info = {
    "k1": {12, 3, 5},
    "k2": {"xx": "x1"}
}

# 字典的键和集合的元素在遇到 布尔值 和 1、0 时，需注意重复的情况。如下实际为1:3
info = {
    1: 0,
    True: 3
}
# 元组的元素不可以被替换
dic = {
    'name': 'test',
    'age': 48,
    'wife': [{'name': 'aaa', 'age': 38}, {'name': 'bbb', 'age': 48}],
    'children': ['第一个娃', '第二个娃']
}
"""
1. 获取test的妻子名字
	d1 = dic['wife'][0]['name']
	print(d1)
2. 获取test的孩子们
	d2 = dic['children']
	print(d2)
3. 获取test的第一个孩子
	d3 = dic['children'][0]
	print(d3)
4. test的媳妇姓名变更为 ccc
	dic['wife'][0]['name'] = "ccc"
	print(dic)
5. test再娶一任妻子
	dic['wife'].append( {"name":"铁锤","age":19} )
	print(dic)

6. 给test添加一个爱好：吹牛逼
	dic['hobby'] = "吹牛逼"
	print(dic)
7. 删除test的年龄
	del dic['age']
	或
	dic.pop('age')
	print(dic)
"""

二、元组

1、定义

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

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

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"   #  不需要括号也可以

创建空元组

tup1 = ()

建议在元组的最后多加一个逗号，用于标识他是一个元组。特别是元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。 

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

#切片
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] )

2、访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

结果
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

3、获取长度

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

4、 for循环

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

# 下标

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



#目前：只有 str、list、tuple 可以被for循环。 "xxx"  [11,22,33]  (111,22,33) 
# len + range + for + 索引
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for index in range(len(user_list)):
    item = user_list[index]
    print(item)

5、修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3) # (12, 34.56, 'abc', 'xyz')

6、删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

#!/usr/bin/python3
 
tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

7、元组运算符

与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

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

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

v1 = ("赵四","刘能")
v2 = ("宋晓峰","范德彪")
v3 = v1 + v2
print(v3) # ("赵四","刘能","宋晓峰","范德彪")

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

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

v1 = ("赵四","刘能")
v2 = v1 * 2
print(v1) # ("赵四","刘能")
print(v2) # ("赵四","刘能","赵四","刘能")

8、元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：


>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', 'Taobao', 'Wiki')
>>>

 9、转换

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

name = "测试"
data = tuple(name)
print(data) # 输出 ("测","试")


name = ["测试",18,"pythonav"]
data = tuple(name)
print(data) # 输出 ("测试",18,"pythonav")

10、嵌套

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

tu = ( 'a', 'b', ('c','d') )
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
tu5 = tu[2][1][3]

print(tu1) # a
print(tu2) # b
print(tu3) # c
print(tu4) # d

11、关于元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。