Python学习今日分享：

Python今日学习内容：多维列表&元组&字典&序列解包

注意事项都在注解中：

# 多维列表
# 二维列表
# 一维列表可以帮我们存储一维，线性的数据
# 二维列表可以帮助我们存储二维，表格的数据
a = [[10, 20, 30], [30, 40, 60]]
# 打印结果为：20
print(a[0][1])

for x in range(2):
     for n in range(3):
         print(a[x][n],end="\t")
     print()

# 元组 tuple
# 列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加元素，修改元素，删除元素的方法
# 因此，我们只需要学习元组的创建和删除，元组中元素的访问和计数即可。元组支持以下操作：1.索引访问  2.切片操作 3.连接操作
# 4.成员关系操作 5.比较运算操作 6.计数：元组长度len()，最大值max(),最小值min(),求和sun()等
#
# 元组的创建:
# 1.通过（）创建元组。小括号可以省略
# 如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把（1）解释为整数1  （1，）解释为元组
a = (10, 20, 30)
# 打印结果为：<class 'tuple'>
print(type(a))

# 2.通过tuple()创建元组   tuple（可迭代的对象）

b = tuple(range(3))
# 打印结果为：(0, 1, 2)
print(b)
b = tuple([2, 3, 5])
# 打印结果为：<class 'tuple'>
print(type(b))
# tuple()可以接收列表，字符串，其他序列型号，迭代器等生成元组。
# list()可以接收元组，字符串，其他序列类型，迭代器等生成列表



# 元组的元素访问和计数
c = (1, 2)
d = (3, 4)
# 打印的结果为：(1, 2, 3, 4)
print(c+d)

# 元组的元素访问和列表一样，只不过返回的仍然是元组对象
a = (1, 2, 4, 10, 100)
# 打印的结果为：2
print(a[1])

# 列表关于排序的方法list.sorted()是修改原来列表对象，元组没有该方法。如果要对元组拍排序，只能使用内置函数sorted(tplobj),并生成新的列表对象
# 打印的结果为:[1, 2, 4, 10, 100]
print(sorted(a))

# zip
# zip(列表1，列表2，....)将多个列表对应位置的元素组合为元组，并返回这个zip对象.

a = [10, 20]
b = [30, 40]
c = [50, 70]
d = zip(a, b, c)
print(list(d))

# 生成器推导式创建元组
s = (x*2 for x in range(5))
# 打印结果为:(0, 2, 4, 6, 8)
print(tuple(s))
# 打印结果为:()
# 只能访问异常元素，第二次就为空了。需要再生成一次
print(tuple(s))

# 元组总结
# 1.元组的核心特点是：不可变序列
# 2.元组的访问和处理速度比列表快
# 3.与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用
#
#
# 字典
# 字典是“键值对”的无序可变序列，字典中的每一个元素都是一个“键值对”，包含：“键对象”和“值对象”。
# 可以通过“键对象”实现快速获取，删除，更新对应的“值对象”。
# 一个典型的字典的定义方式：
a = {'name': 'gao', "age": 18}
# 打印的结果为：{'name': 'gao', 'age': 18}
print(a)

# 字典的创建
# 1.我们可以通过{}，dict()来创建字典对象。
b = dict(name="xs", age=18)
# 打印的结果为： {'name': 'xs', 'age': 18}
print(b)
# 空的字典对象
c = {}
d = dict()
# 2.通过zip()创建字典对象
k = ['name', 'age']
v = ['xs', 15]
d = dict(zip(k, v))
# 打印的结果为：{'name': 'xs', 'age': 15}
print(d)


# 3.通过fromkeys 创建值为空的字典
e = dict.fromkeys(['name', 'age'])
# 打印结果为：{'name': None, 'age': None}
print(e)


# 字典元素的访问
# 1.通过[键]获得“值”.若键不存在，则抛出异常
a = {'name': 'gao', "age": 18}
# 打印结果为：gao
# print(a["name"])

# 2.通过get()方法获得“值”.推荐使用。 优点是：指定键不存在，返回node；也可以设指定键不存在时默认返回的对象。推荐使用get()获取“值对象”
# 打印结果为：gao
# print(a.get("name"))
# 打印结果为：None 不存在
print(a.get("123"), "不存在")


# 3.列出所有的键值对
# 打印结果为： dict_items([('name', 'gao'), ('age', 18)])
print(a.items())

# 4.列出所有的键，列出所有的值
# 打印结果为：dict_keys(['name', 'age'])
print(a.keys())
# 打印的结果为：dict_values(['gao', 18])
print(a.values())

# 5.len()键值对个数
# 打印的结果为：2
print(a.__len__())

# 6.检测一个“键"是否在字典中
# 打印的结果为：True
print("name" in a)


# 字典元素添加，修改，删除
a = {'name': 'gao', "age": 18}
# 1.给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键不存在”，则新增“键值对”
# 打印结果为：{'name': 'gao', 'age': 17, 'cs': '123'}
a["cs"] = "123"
a['age'] = 17
print(a)

# 2.使用upate()将新字典中所有键值对全部添加到旧字典上，如果key有重复,则直接覆盖
b = {"name": "da", "age": 1, "sex": "男"}
a.update(b)
print(a)
# 3.字典中元素的删除，可以使用del()方法；或者clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”
del(a['name'])
# 打印的结果为：{'age': 1, 'cs': '123', 'sex': '男'}
print(a)
a.pop("cs")
# 打印的结果为：{'age': 1, 'sex': '男'}
print(a)
a.clear()
# 打印的结果为：{}
print(a)

# 4.popitem():返回并删除最后一位的键值对

a = {'name': 'gao', "age": 18, "ces": 22}
a.popitem()
print(a)
a.popitem()
print(a)


# 序列解包
# 序列解包可以用于元组，列表，字典，序列解包可以让我们方便的对多个变量赋值
x, y, z = (20, 30, 10)
# 打印结果为：20
print(x)
# 30
print(y)
# 10
print(z)

# 序列解包用于字典时，默认是对“键”进行操作；如果需要对键值对操作，则需要使用items();如果需要对“值”进行操作，则需要使用values();
a = {'name': 'gao', "age": 18, "ces": 22}
# 默认对键进行操作
name, age, ces = a
# 打印的结果为：
# name
# age
# ces
print(name)
print(age)
print(ces)

name, age, ces = a.values()
# 打印的结果为:
# gao
# 18
# 22
print(name)
print(age)
print(ces)