元组和字典

元组和字典

1.元组

1.元组
a.不可变的列表；
b.容器型数据类型，将()作为容器的标志，里面多个元素用逗号隔开；
(元素1, 元素2, 元素3, …)
c.元组不可变(不支持元素的增删改)；元组是有序的(支持下标操作)；
d.元素：任何类型的数据，并且可以重复；
e.注意:只有一个元素的元组，唯一元素的后面要加逗号；

t1 = (10,)
print(t1, type(t1))
# (10,) <class 'tuple'>

2.省略括号
在没有歧义的情况下，可以省略()，直接将多个元素用逗号隔开来表示一个元素；

t2 = 'abc', 10, 100, True
# ('abc', 10, 100, True) <class 'tuple'>
print(t2, type(t2))

3.获取元素
1)列表获取元素的方法元组都支持

letter = ('a', 'b', 'c', 'd')
print(letter[1:])
# ('b', 'c', 'd')

for x in letter:
    print('x:', x)
# x: a
# x: b
# x: c
# x: d

for index, item in enumerate(letter):
    print(index, item)
# 0 a
# 1 b
# 2 c
# 3 d

for index in range(len(letter)):
    print(letter[index])
# a
# b
# c
# d

2)让变量的个数等于元素的个数来获取元组中的所有的值

t3 = (10, 100, 1000)
x, y, z = t3
print(x, y, z)
# 10 100 1000

3)让变量的个数小于元组的个数来获取元组元素的时候，必须有且只有一个变量前有*

stu = ('小明', '男', 30, 89, 70, 170)
m1, m2, *m3 = stu
print('m1:', m1, 'm2:', m2, 'm3:', m3)
# m1: 小明 m2: 男 m3: [30, 89, 70, 170]

m1, *m2, m3 = stu
print('m1:', m1, 'm2:', m2, 'm3:', m3)
print(type(m2))
# m1: 小明 m2: ['男', 30, 89, 70] m3: 170
# <class 'list'>

4）元组相关操作
列表相关操作元组都支持
a.加法运算
b.乘法运算
c.比较运算
d.in和not in
e.相关函数sum、max、min、len、sorted（对元组排序结果为列表）
f.类型转换：tuple1=tuple(序列)
g.切片

2.字典

1.字典(dict) - 同时保存多个意义不同的数据就使用字典

a. 容器型数据类型,将{}作为容器的标志,里面多个元素用逗号隔开(元素必须是键值对)
{键1:值1, 键3:值3, 键3:值3, …}
键:必须是不可变的数据(数字、字符串、元组),一般使用字符串;键是用来对值进行描述和区分的,唯一的;
值:没有要求
b.字典是可变的(支持增删改)
c.字典是无序的(不支持下标操作)
d.字典不支持加法、乘法运算，也不支持比较大小

空字典

dict1 = {}
print(type(dict1))  # <class 'dict'>

键是唯一的

dict2 = {'name': '小饼干', 'age': 18, 'name': '小饼干'}
print(dict2)
# {'name': '小饼干', 'age': 18}

字典无序

print({'a': 10, 'b': 20} == {'b': 20, 'a': 10})  # True

2.字典的增删改查

1）查 - 获取值

a.字典[key] - 获取指定key对应的值
b.字典.get(key) - 获取指定key对应的值(key不存在会报错，返回None)
c.字典.get(key, 默认值) - 获取指定key对应的值(key不存在会报错，返回默认值)

dict3 = {'name': '小饼干', 'age': 18, 'high': 178}
print(dict3['name'])  # 小饼干
print(dict3.get('weight', '不存在'))  # 不存在

1.2）遍历

for 变量 in 字典:
pass

注意：变量取的是键

for key in dict3:
    print(key, dict3[key])
# name 小饼干
# age 18
# high 178

2）增、改

字典[key] = 值
a.当key存在时候，修改键值对
b.当key不存在时，添加键值对

dict4 = {'name': '张轩', 'age': 18, 'high': 155}
dict4['age'] = 24
print(dict4)  # {'name': '小饼干', 'age': 24, 'high': 178}
dict4['weight'] = 150
print(dict4)  # {'name': '张轩', 'age': 24, 'high': 155, 'weight': 150}

3）删

a.del 字典[key] - 删除指定key对应的键值对（会报错）
b.字典.pop（key） - 取出指定key对应的键值对

del dict4['high']
print(dict4)  # {'name': '张轩', 'age': 24, 'weight': 150}
dict4.pop('weight')
print(dict4)  # {'name': '张轩', 'age': 24}

3.字典的相关操作

1）in 和 not in
key in（或not in） 字典 - 判断字典中是否存在指定

d1 = {'a': 10, 'b': 12}
print('a' in d1)  # True

2）相关函数：len()、dict(数据)

a. len(字典) - 求字典的长度(当前字典键值对的数量)
b. dict(数据) - 将指定数据转换成字典
​ 数据的要求 :
​ 1.数据本身是序列
​ 2.序列中的每个元素必须是长度为2的小序列
​ 3.小序列中的第一个元素是不可变的数据

date = ['ab', (10, 20), ['abc', 123]]
print(dict(date))  # {'a': 'b', 10: 20, 'abc': 123}

d1 = {'a': 10, 'b': 20, 'c': 30}
print(list(d1))  # ['a', 'b', 'c']

3）相关方法

a. 字典.clear() - 清空字典
b. 字典.copy() - 复制字典产生一个一模一样的新字典并返回(产生一个地址不同的字典)
c. dict.fromkeys(序列) - 创建一个新的字典，键是序列中的每一个元素，值都是None
dict.fromkeys(序列, 值) - 创建一个新的字典，键是序列中的每一个元素，值都是指定的值

print(dict.fromkeys('abc'))
# {'a': None, 'b': None, 'c': None}
print(dict.fromkeys('abc', 100))
# {'a': 100, 'b': 100, 'c': 100}	

d. 字典.keys() - 获取字典所有的键(返回值是序列但不是列表)
字典.values() - 获取字典所有的值(返回值是序列但不是列表)
字典.items() - 同时获取字典所有的键和对应的值(返回值是序列但不是列表)

d1 = {'a': 10, 'b': 20, 'c': 30}
print(d1.keys())   # dict_keys(['a', 'b', 'c'])
print(d1.values())  # dict_values([10, 20, 30])
print(d1.items())  # dict_items([('a', 10), ('b', 20), ('c', 30)])

e. 字典.setdefault(键, 值) - 在字典中添加键值对(只添加不修改),如果键已经存在，就不做任何改动

d1 = {'a': 10, 'b': 20, 'c': 30}
d1.setdefault('age', 18)
print(d1)  # {'a': 10, 'b': 20, 'c': 30, 'age': 18}

f. 字典1.update(字典2) - 将字典2中所有的键值对添加到字典1中

d1 = {'a': 10, 'b': 20, 'c': 30}
d1.update(('mn', [10, 20]))
print(d1)
# {'a': 10, 'b': 20, 'c': 30, 'm': 'n', 10: 20}