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

序列

元组tuple

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

元组的核心特点是：不可变序列。

元组的访问和处理速度比列表快。

与整数和字符串一样，元组可以作为字典的键(不可在原地址更改)，列表则永远不能作为字典的键使用。

元组支持如下操作：

索引访问

切片操作

连接操作

成员关系操作

比较运算操作

元组长度len()、最大值max()、最小值min()、求和sum()等。

元组的创建

()创建元组

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

a = (1,2,3)

b = 4,5,6

c = (7,) # 元组只有一个元素，后面必须加逗号

d = 8,

e = (9) # 后不加逗号，解释器会解释为整数

type(d) #

type(e) #

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)

生成器推导式创建元组

列表推导式直接生成列表对象，但生成器推导式生成的不是元组也不是列表，是一个生成器对象。

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

s = (x*2 for x in range(5))

type(s) # ，生成器对象

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

list(d) # [(10, 40, 70), (20, 50, 80), (30, 60, 90)]，列表对应位置打包成一个元祖

字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。

列表中是通过“索引数字”找到对应对象，字典中则通过“键对象”找到对应的“值对象”。

“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。“值”可以是任意的数据，并且可重复。

字典的创建

{}创建

a = {"学号":1511,"年龄":25,"科目":"python","学号":1544}

a # {'科目': 'python', '学号': 1544, '年龄': 25}，“键”不可重复，若重复新值覆盖原先的值

type(a) # ，{键1:值1,键2:值2...}

b = {} #空的字典对象

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

d = dict(s) # {'科目': 'python', '学号': 1544, '年龄': 25}

list(s) # []，zip对象只能调用一次，实现列表对应位置压缩为一个元祖

list(zip(x,y)) # [('学号', 1544), ('年龄', 25), ('科目', 'python')]

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

删除字典所有键值对

字典元素的访问

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

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

a["学号"] # 1544

a["性别"] # 报错

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

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

a.get("年龄") # 25

print(a.get("性别")) # None

a.get("身高","未知") # '未知'

字典函数

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

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

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

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

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

a.keys() # dict_keys(['科目', '学号', '年龄'])

a.values() # dict_values(['python', 1544, 25])

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

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

len(a) # 3

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

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

'学号' in a # True

字典元素的添加

dict[键] = 值

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

a = {"学号":1511,"年龄":25,"科目":"python"}

a["性别"] = "女"

a["学号"] = 1544

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

dict.update(Dict)

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

a = {"学号":1511,"年龄":25,"科目":"python"}

b = {'学号': 1544,'性别':'女','身高':168}

a.update(b)

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

字典元素的删除

del()方法

del(dict[键])，删除指定键值对

a = {"学号":1511,"年龄":25,"科目":"python"}

del(a['年龄'])

print(a) # {'科目': 'python', '学号': 1511}

pop()方法

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

a = {"学号":1511,"年龄":25,"科目":"python"}

b = a.pop('年龄')

print(a,b) # {'科目': 'python', '学号': 1511} 25

popitem()方法

因为字典是无序可变序列，所以没有第一个元

素和最后一个元素的概念；popitem()可实现随机一个接一个地移除并处理键值对

a = {"学号":1511,"年龄":25,"科目":"python"}

b = a.popitem() # ('科目', 'python')

c = a.popitem() # ('年龄', 25)

print(a,b,c) # {'学号': 1511}

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

未经允许不得转载：作者:1544-陈同学，

转载或复制请以 超链接形式 并注明出处 拜师资源博客。