python学习笔记_第6天（元组+字典）

序列

元组tuple

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。

• 元组的核心特点是：不可变序列。
• 元组的访问和处理速度比列表快。
• 与整数和字符串一样，元组可以作为字典的键（不可在原地址更改），列表则永远不能作为字典的键使用。
  元组支持如下操作：

1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 元组长度len()、最大值max()、最小值min()、求和sum()等。

元组的创建

1. ()创建元组
   ()创建元组，小括号可以省略。当元组内只有一个元素时，创建元组单个元素后要加逗号。

a = (1,2,3)
b = 4,5,6
c = (7,)  # 元组只有一个元素，后面必须加逗号
d = 8,
e = (9)  # 后不加逗号，解释器会解释为整数
type(d)  # <class 'tuple'>
type(e)  # <class 'int'>

2. tuple()创建元组
   与list()创建列表相似,括号内为可迭代对象。
   tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
   list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

b = tuple()  # 创建一个空元组对象
b = tuple("abc")  # ('a', 'b', 'c')
b = tuple(range(3))  # (0, 1, 2)
b = tuple([2,3,4])  # (2, 3, 4)

3. 生成器推导式创建元组
   列表推导式直接生成列表对象，但生成器推导式生成的不是元组也不是列表，是一个生成器对象。
   可以通过list() 或 tuple()，将生成器对象转化成列表或者元组。也可以使用生成器对象的__next__()方法移动指针，来进行生成器对象中各元素的遍历，或者直接作为迭代器对象来使用。生成器对象只可被访问一次，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。

s = (x*2 for x in range(5))
type(s)  # <class 'generator'>，生成器对象
tuple(s)  # (0, 2, 4, 6, 8)
list(s)  # []，只能访问一次元素。重新访问，需要再生成一次
tuple(s)  # ()

s = (x*2 for x in range(5))
s.__next__()  # 0，以双下划线开头和结尾的名称通常有特殊含义
s.__next__() # 2，使用.__next__()移动指针，依次指向单个元素
s.__next__()  # 4

元组对象的常用函数

功能	函数	说明
访问元素	tuple[index]	通过索引直接访问， 索引区间超出[0, 元组长度-1]的范围报错
排序	sorted(tuple[,reverse=True])	返回新的排序列表，可用tuple()转换成元组。默认升序，不对原元组做修改

• 元组的元素访问
  元组的元素不能修改，元组的元素访问和列表一样，返回的仍然是元组对象。

a = (1,2,3,4,5,6)
a[2]  # 3
a[-4::2]  # (3, 5)
a[::-1]  # (6, 5, 4, 3, 2, 1)
a[3]  = 0  # 报错

• 元组排序
  列表可以list.sorted()修改原列表对象，但元组无法修改，没有该方法。对元组排序，只能使用内置函数sorted()，并生成新的列表对象。

a = (3,2,5,4,1)
id(a)  # 85353136
sorted(a)  # <class 'list'>，[1, 2, 3, 4, 5]
b = tuple(sorted(a))  # 可以将迭代对象列表转换为元祖
c = tuple(sorted(a,reverse=True))  # reverse=True，降序
id(b)  # 76814736
id(c)  # 85354280

• zip打包
  zip(列表1，列表2，…)将多个列表对应位置的元素组合成为元组，并返回这个zip 对象。

a = [10,20,30]
b = [40,50,60]
c = [70,80,90]
d = zip(a,b,c)
type(d)  # <class 'zip'>
list(d)  # [(10, 40, 70), (20, 50, 80), (30, 60, 90)]，列表对应位置打包成一个元祖

字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
列表中是通过“索引数字”找到对应对象，字典中则通过“键对象”找到对应的“值对象”。
“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。“值”可以是任意的数据，并且可重复。

字典的创建

1. {}创建

a = {"学号":1511,"年龄":25,"科目":"python","学号":1544}
a  # {'科目': 'python', '学号': 1544, '年龄': 25}，“键”不可重复，若重复新值覆盖原先的值
type(a)  # <class 'dict'>，{键1:值1,键2:值2...}
b = {} #空的字典对象

2. dict()+zip()创建
   zip(列表1，列表2，…)将多个列表对应位置的元素组合成为元组，并返回这个zip 对象。

a = dict(学号=1544,年龄=25,科目="python")   # 格式一：dict（键1 = 值1,键2 = 值2...)，键不需要加引号

b = dict([("学号",1544),("年龄",25),("科目","python")])  # 格式二：dict（[(键1,值1),(键2 ,值2)...])
c = dict()  # 空的字典对象

x = ["学号","年龄","科目"]
y = [1544,25,"python"]
s = zip(x,y)  # <class 'zip'>
d = dict(s)  # {'科目': 'python', '学号': 1544, '年龄': 25}
list(s)  # []，zip对象只能调用一次，实现列表对应位置压缩为一个元祖
list(zip(x,y))  # [('学号', 1544), ('年龄', 25), ('科目', 'python')]

3. fromkeys 创建值为空的字典

a = dict.fromkeys(["学号","年龄","科目"])
a  # {'科目': None, '学号': None, '年龄': None}

字典对象的常用函数

功能	函数	说明
访问值	dict[key]	通过[键] 获得“值”。若键不存在，则抛出异常。
访问值	dict.get(key)	当指定键不存在不报错，默认返回None，返回值可指定
遍历键值对（解包键值对）	dict.items()	列出所有的键值对，每组键值对以元组形式分装
遍历键（解包键）	dict.keys()	列出所有的键
遍历值（解包值）	dict.values()	列出所有的值
键值对个数	len(list)	返回字典中包含键值对的个数
增加键值对	list[键] = 值	“键”不存在，则新增“键值对”；“键”已经存在，则覆盖旧的键值对
增加键值对	list.update(List)	新字典中所有键值对全部添加到旧字典上，有重复则直接覆盖。
删除键值对	del(dict[键])	删除指定键值对
删除键值对	dict.pop(键)	删除指定键值对，并可以返回对应的值
删除键值对	dict.popitem()	随机一个接一个地移除并处理键值对
删除所有键值对	dict.clear()	删除字典所有键值对

• 字典元素的访问

1. 通过[键] 获得“值”。若键不存在，则抛出异常。

a = {"学号":1544,"年龄":25,"科目":"python"}
a["学号"]  # 1544
a["性别"]  # 报错

2. 通过get()获得“值”，优点是当指定键不存在不报错，默认返回None；还可以设定指定键不存在时默认返回的对象。推荐使用get()获取“值对象”。

a = {"学号":1544,"年龄":25,"科目":"python"}
a.get("年龄")  # 25
print(a.get("性别"))  # None
a.get("身高","未知")  # '未知'

• 字典函数

1. dict.items()，列出所有的键值对

a = {"学号":1544,"年龄":25,"科目":"python"}
a.items()  # dict_items([('科目', 'python'), ('学号', 1544), ('年龄', 25)])，字典无序

2. dict.keys()，列出所有的键；dict.values()，列出所有的值

a = {"学号":1544,"年龄":25,"科目":"python"}
a.keys()  # dict_keys(['科目', '学号', '年龄'])
a.values()  # dict_values(['python', 1544, 25])

3. len()，返回键值对的个数

a = {"学号":1544,"年龄":25,"科目":"python"}
len(a)  # 3

4. 判断一个“键”是否在字典中

a = {"学号":1544,"年龄":25,"科目":"python"}
'学号' in a  # True

• 字典元素的添加

1. dict[键] = 值
   直接对新键赋值，如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对”。

a = {"学号":1511,"年龄":25,"科目":"python"}
a["性别"] = "女"
a["学号"] = 1544
print(a)  # {'性别': '女', '科目': 'python', '年龄': 25, '学号': 1544}

2. dict.update(Dict)
   将新字典中所有键值对全部添加到旧字典对象上。如果key 有重复，则直接覆盖。

a = {"学号":1511,"年龄":25,"科目":"python"}
b = {'学号': 1544,'性别':'女','身高':168}
a.update(b)
print(a)  # {'身高': 168, '性别': '女', '科目': 'python', '年龄': 25, '学号': 1544}，字典无序

• 字典元素的删除

1. del()方法
   del(dict[键])，删除指定键值对

a = {"学号":1511,"年龄":25,"科目":"python"}
del(a['年龄'])
print(a)  # {'科目': 'python', '学号': 1511}

2. pop()方法
   dict.pop(键)删除指定键值对，并可以返回对应的值

a = {"学号":1511,"年龄":25,"科目":"python"}
b = a.pop('年龄')
print(a,b)  # {'科目': 'python', '学号': 1511} 25

3. popitem()方法
   因为字典是无序可变序列，所以没有第一个元
   素和最后一个元素的概念；popitem()可实现随机一个接一个地移除并处理键值对

a = {"学号":1511,"年龄":25,"科目":"python"}
b = a.popitem()  # ('科目', 'python')
c = a.popitem()  #  ('年龄', 25)
print(a,b,c)  #  {'学号': 1511}

4. clear()方法
   dict.clear()删除所有键值对

a = {"学号":1511,"年龄":25,"科目":"python"}
a.clear()
print(a)  # {}

• 序列解包
  序列解包可以用于元组、列表、字典，可以更方便的对多个变量赋值。
  序列解包用于字典时，默认是对“键”进行操作； 如果需要对键值对操作，则使用dict.items()；如果需要对“值”进行操作，则使用dict.values()。

# 元组
x,y,z = (1,2,3)  # 创建元组可省略括号
print(x,y,z)  # 1 2 3
(a,b,c) = (7,8,9)
print(a,b,c)  # 7 8 9

# 列表
[x,y,z] = [10,20,30]
print(x,y,z)  # 10 20 30

#字典
a = {"学号":1511,"年龄":25,"科目":"python"}
x,y,z = a  # 默认对键进行操作
print(x,y,z)  # 科目 年龄 学号

b,c,d = a.items()  # 对键值对进行操作
print(b,c,d)  # ('科目', 'python') ('年龄', 25) ('学号', 1511)

e,f,g = a.values()  # 对值进行操作
print(e,f,g)  # python 25 1511

字典与列表小练习

表格数据使用字典和列表存储，并实现访问

r1 = {'name':'张三‘,'chinese':90,'english’:100,'math':98}
r2 = {'name':'李四‘,'chinese':88,'english’:100,'math':90}
r3 = {'name':'王五‘,'chinese':93,'english’:90,'math':98}
mark = [r1,r2,r3]

# 获取第二行学生的数学分数
print(mark[1].get('math'))  

# 获取表内所有学生的数学分数
for i in range(len(mark)):
	print(mark[i].get('math'))  

# 读取表格中每行数据
for i in range(len(mark)):
	print(mark[i].get('name'),mark[i].get('chinese'),mark[i].get('english'),mark[i].get('math'))