day06回顾
列表
可变的序列容器
创建列表的方法:
字面值 [], [1, 2, 3]
构造函数 list() , list(range(10))
推导式 [x**2 for x in range(10)]
运算符:
+ += * *=
< <= > >= == !=
in / not in
索引
索引取值
v = L[1]
索引赋值
L[1] = 100
切片
切片取值
L[a:b] L[a:b:c] 注意: 切片取值返回的是列表
切片赋值
L[a:b] = 可迭代对象
L[a:b:c] = 可迭代对象
当c不等同于1时,切片赋值,切出的段数等于可迭代对象提供
的个数
可以用于序列的函数:
len(x), max(x), min(x), sum(x), any(x), all(x)
reversed(x) 返转迭代输出的顺序
sorted(x, reverse=False) 对x迭代取出的数据进行排序,
返回排序后的列表
列表的方法:
L.index(v)
L.append(x) 追加
L.count(x)
L.extend(可迭代对象) # 扩展
L.copy() # 复制
L.reverse() # 反转
L.remove(x) # 按值来删除第一个
L.clear() # 全删除
v = L.pop([index]) 按索引来移除元素
L.sort(reverse=False) 将列表中的元素进行排序
深拷贝, 浅拷贝
字符串的解析方法:
S.split(sep=None) # 用sep拆分为列表
S.splitlines() # 用换行符拆分为列表
S.join(iterable) # 将列表组合成为字符串
列表推导式
[表达式 for 变量1 in 可迭代对象1 if 真值表达式1
for 变量2 in 可迭代对象2 if ....
....]
day07笔记
元组 tuple
元组是不可改变的序列,同list一样,元组是可以存入任意类型数据
的容器
元组的表示方式:
用小括号()括起来,单个元素括起来后加逗号(,)区分单个对象还是
元组
创建空元组的字面值
t = ()
创建非空元组的字面值
t = 200,
t = (20,)
t = (1, 2, 3)
t = 100, 200, 300
注:
type(x) 函数用来返回x的类型
元组创建的错误示例:
t = (20) # t 绑定20这个整数,不是绑定元组
x, y, z = 100, 200, 300 # 序列赋值,不是元组
x, y, z = (100, 200, 300)
x, y, z = [100, 200, 300]
x, y, z = "ABC" # 序列赋值,不是元组
元组的构造函数(创建)函数 tuple
tuple() 生成一个空的元组,等同于()
tuple(iterable) 用可迭代对象生成一个元组
示例:
t = tuple() 创建空元组,等同于 t = ()
t = tuple(range(1, 10, 3)) # 创建非空元组
元组的运算:
运算符:
+ += * *=
+ 加号用于拼接
t = (1, 2, 3) + (4, 5, 6) # t = (1, 2, 3, 4, 5, 6)
+= 拼接后再赋值
x = (1, 2, 3)
y = (4, 5, 6)
x += y # 等同于 x = x + y
注: 因为元组不可变,加后的ID会发生变化
* 生成重复的元组
*= 生成重复的元组再重新赋值绑定
x = (1, 2) * 3
print("x=", x)
x = (1, 2, 3)
x *= 2 # x = (1, 2, 3, 1, 2, 3)
元组的比较运算
运算符:
< <= > >= == !=
说明:
元组比较规则和列表比较规则完全相同
in / not in 运算符:
x = (1, 'two', 3)
2 in x # False
3 in x # True
5 in x # False
5 not in x # True
索引 index
用法等同于列表的索引
元组不能索引赋值
切片 slice
用法等同于列表的切片,元组的切片返回一个新的元组
元组不能切片赋值
元组的方法:
文档参见:
python_base_docs_html/tuple.html
序列相关的函数总结:
# 以下函数可以用于序列: 字符串,列表,元组
len(x) , max(x), min(x), sum(x), any(x), all(x)
构造函数:
str(x)
list(x)
tuple(x)
reversed(x) , sorted(x, reverse=False)
练习:
生成一个1~9的平方的元组,元组如下:
(1, 4, 9, 16, 25, ...., 81)
1 # 生成一个1~9的平方的元组,元组如下: 2 # (1, 4, 9, 16, 25, ...., 81) 3 4 # 方法1 5 # t = () 6 # for x in range(1, 10): 7 # t += (x**2,) 8 9 # 方法2 10 # L = [x ** 2 for x in range(1, 10)] 11 # t = tuple(L) 12 13 # 方法3 14 # t = tuple(x**2 for x in range(1, 10)) 15 # 等同于如下: 16 g = (x**2 for x in range(1, 10)) 17 t = tuple(g) 18 19 print(t) 20
字典 dict
1. 字典是一种可变的容器,可以存储任意类型的数据
2. 字典中的每个数据都是用'键'(key)进行索引,而不像序列可以
用下标进行索引
3. 字典中的数据没有先后关系,字典的存储是无序的
4. 字典中的数据以键(key)-值(value)对的形式进行存储.
5. 字典的键不能重复,且只能用不可变类型作为字典的键
字典的字面值表示方法:
字典的表示方式是用 {} 括起来, 以冒号(:) 分隔键-值对,各
键值对之间用逗号分隔开
创建空字典的字面值:
d = {} # 空字典
创建非空的字典
d = {'姓名': '小张', '年龄': 20}
d = {1: '一', 2:"二", 5:'五'}
dict的构造(创建) 函数dict
dict() 生成一个空的字典,等同于{}
dict(iterable) 用可迭代对象创建一个字典
dict(**kwargs) 用关键字传参形式生成一个字典(字典的键名
必须是符合标识符命名规则的字符串)
示例:
d = dict()
L = [('姓名', '小张'), ['年龄', 20], "AB"]
d = dict(L)
d = dict(name='小张', age=20)
字典的键(key) 必须为不可变的数据类型,可以用数字,字符串,
元组等充当字典的键
python3中不可变的数据类型:
bool, int, float, complex, str, tuple,
frozenset(固定集合,后面才讲), bytes(字节串)
包括: None
python3中可变的数据类型:
列表list, 字典dict, set(集合), bytearray(字节数组)
示例:
d = {'a': 100}
d = {'a': (1, 2, 3)}
d = {(1, 2, 3): 'a'}
d = {'a': [1, 2, 3]}
d = {[1, 2, 3]: 'a'} # 报错,列表不能做为键
d = {'a': {'b': 100, 'c': 200}}
d = {{1:'一'}: '壹'} # 报错,字典不能做键
字典的基本操作
字典的键索引
用[] 运算符可以获取字典内"键"所对应的"值"
取值语法:
变量 = 字典[键]
示例:
d = {'name': 'tarena', 'age': 20}
print(d['name'], '今年', d['age'], '岁')
添加和修改字典的键值对
语法:
字典[键] = 表达式
说明:
键不存在,创建键,并绑定键对应的值
键存在,修改键绑定的值
示例:
d = {}
d['name'] = 'tarena' # 创建新键值对
d['age'] = 15
d['age'] = 16 # 修改age键对应的值为16
删除字典的元组 del语句
语法:
del 字典[键]
作用:
删除字典的键,同时解除对值的绑定
示例:
d = {'name': 'tarena', 'age': 20}
del d['age']
in / not in 运算符
用于字典中, in 运算符用来判断一个"键"是否存在于字典中,如果
存在则返回True,否则返回False
not in 与 in 结果相反
示例:
d = {'name': 'tarena', 'age': 15}
'name' in d # True
30 in d # False
'tarena' in d # False
15 not in d # True
注: 只判断键是否存在,不判断值是否存在
练习:
写程序,实现以下要求:
1. 将如下数据形成一个字典seasons
'键' '值'
1 -----> '春季有1,2,3月'
2 -----> '夏季有4,5,6月'
3 -----> '秋季有7,8,9月'
4 -----> '冬季有10,11,12月'
让用户输入一个整数代表这个季度,打印这个季度的信息,如果用户
输入的信息不在字典内,则打印"信息不存在"
1 # 练习: 2 # 写程序,实现以下要求: 3 # 1. 将如下数据形成一个字典seasons 4 # '键' '值' 5 # 1 -----> '春季有1,2,3月' 6 # 2 -----> '夏季有4,5,6月' 7 # 3 -----> '秋季有7,8,9月' 8 # 4 -----> '冬季有10,11,12月' 9 10 # 让用户输入一个整数代表这个季度,打印这个季度的信息,如果用户 11 # 输入的信息不在字典内,则打印"信息不存在" 12 13 # 方法1 14 # seasons = { 15 # 1: '春季有1,2,3月', 16 # 2: '夏季有4,5,6月', 17 # 3: '秋季有7,8,9月', 18 # 4: '冬季有10,11,12月' 19 # } 20 # 方法2 21 seasons = {} 22 seasons[1] = '春季有1,2,3月' 23 seasons[2] = '夏季有4,5,6月' 24 seasons[3] = '秋季有7,8,9月' 25 seasons[4] = '冬季有10,11,12月' 26 27 # print(seasons) 28 x = int(input('请输入季度(1~4):')) 29 if x in seasons: 30 print(seasons[x]) 31 else: 32 print("信息不存在") 33 34 35 36 37
字典是可迭代对象
字典只能对键进行迭代访问
示例:
d = {'name': 'tarena', 'birthday': (2002,1,1)}
for k in d:
print(k)
字典的比较运算:
运算符:
== !=
说明:
只有键和值都完全相同时,才相等,否则不相等
示例:
{1: '一', 2: '二'} == {1: '一', 2: '二'} # True
{1: '一', 2: '二'} == {1: '1', 2: '2'} # False
可以用于字典的内建 函数
len(x) 返回字典的键值对的个数
max(x) 返回字典的键的最大值
min(x) 返回字典的键的最小值
sum(x) 返回字典中所有键的和
any(x) 真值测试,如果字典中其中一个键为真值则返回True
all(x) 真值测试,如果字典全部键为真值才返True
示例:
d = {0: '零', 5: '伍', 8: '捌', 3: '参'}
len(d) # 4
max(d) # 8
min(d) # 0
sum(d) # 16
any(d) # True
all(d) # False
字典的方法
文档参见:
python_base_docs_html/dict.html
使用方法:
字典.方法名(方法传参)
示例:
d1 = {1: 'one', 2: '二', 3: '三'}
for t in d1.items():
print(t) # (1, 'one'), (2, '二'), (3, '三')
for k, v in d1.items():
print('k=', k, 'v=', v)
练习:
写一个程序，输入一个字符串，写程序统计出这个字符串的字符
个数的字符的种类
如:
请输入: ABCDABCABA
输出结果:
字符 A: 4次
字符 B: 3次
字符 D: 1次
字符 C: 2次
（注: 不要求输出的顺序)
1 # 练习: 2 # 写一个程序，输入一个字符串，写程序统计出这个字符串的字符 3 # 个数的字符的种类 4 # 如: 5 # 请输入: ABCDABCABA 6 # 输出结果: 7 # 字符 A: 4次 8 # 字符 B: 3次 9 # 字符 D: 1次 10 # 字符 C: 2次 11 # （注: 不要求输出的顺序) 12 13 s = input("请输入: ") 14 # 统计字符的个数: 15 # 如果第一次出现这个字符: 16 # 用这个字符创建字典的键，值为1 17 # 如果第二次或之后出现这个字符，直接将键对应的值加1 18 d = {} 19 for ch in s: 20 if ch not in d: # 第一次出现 21 d[ch] = 1 22 else: 23 d[ch] += 1 24 25 # print('d=', d) 26 for k in d: 27 print("字符", k, ':', d[k], '次') 28
字典推导式:
字典推导式是用可迭代对象依次生成字典内元素的表达式
语法:
{键表达式: 值表达式 for 变量 in 可迭代对象 [if 真值表达式] ...}
注: [] 的内容代表可省略
示例:
生成一个字典，键为数字(10以内), 值为键的平方
d = {x : x ** 2 for x in range(10)}
练习:
1. 有如下字符串列表:
L = ['tarena', 'xiaozhang', 'hello']
生成如下字典:
d = {'tarena': 6, 'xiaozhang': 9, 'hello': 5}
注: 字典的值为键的长度
答案:
d = {k: len(k) for k in L}
2. 已知有两个字符串列表:
Nos = [1001, 1002, 1005, 1008]
names = ['Tom', 'Jerry', 'Spike', 'Tyke']
生成以Nos 中项为键，以names中的项为值的字典
d = {1001: 'Tom', 1002:'Jerry', ....}
1 # 2. 已知有两个字符串列表: 2 # Nos = [1001, 1002, 1005, 1008] 3 # names = ['Tom', 'Jerry', 'Spike', 'Tyke'] 4 5 # 生成以Nos 中项为键，以names中的项为值的字典 6 # d = {1001: 'Tom', 1002:'Jerry', ....} 7 8 9 10 Nos = [1001, 1002, 1005, 1008] 11 names = ['Tom', 'Jerry', 'Spike', 'Tyke'] 12 13 # d = {} 14 # for i in range(len(Nos)): 15 # # print(i) 16 # d[c] = names[i] 17 18 d = {Nos[i]: names[i] for i in range(len(Nos))} 19 # d = {x: y for x in Nos for y in names} # 错误 20 21 22 23 print(d) 24 25 26 27 28
1 # 2. 已知有两个字符串列表: 2 # Nos = [1001, 1002, 1005, 1008] 3 # names = ['Tom', 'Jerry', 'Spike', 'Tyke'] 4 5 # 生成以Nos 中项为键，以names中的项为值的字典 6 # d = {1001: 'Tom', 1002:'Jerry', ....} 7 8 9 10 Nos = [1001, 1002, 1005, 1008] 11 names = ['Tom', 'Jerry', 'Spike', 'Tyke'] 12 13 # d = {} 14 # for n in Nos: 15 # d[n] = names[Nos.index(n)] 16 17 d = {n: names[Nos.index(n)] for n in Nos} 18 19 print(d) 20 21 22 23 24
字典 VS 列表
1. 都是可变对象
2. 索引方式不同，列表用整数索引，字典用键索引
3. 字典的插入，删除，修改的速度可能会快于列表（重要)
4. 列表的存储是有序的，字典的存储是无序的
练习:
1. 思考下面的程序的执行结果是什么？为什么？
L = list(range(10))
for x in L:
L.remove(x)
print("L=", L) # 请问是空列表吗？
1 # 1. 思考下面的程序的执行结果是什么？为什么？ 2 # L = list(range(10)) 3 # for x in L: 4 # L.remove(x) 5 # print("L=", L) # 请问是空列表吗？ 6 7 8 L = list(range(10)) 9 # for x in L: 10 # print("+++++") 11 # L.remove(x) 12 13 while L: 14 L.remove(L[0]) 15 16 print("L=", L) # 请问是空列表吗？ 17
2. 输入一些单词和解释,将单词作为键,将解释作为值,存入字典中
当输入单词或解释为空是停止输入,并打印这个字典
然后,输入查询的单词,给出单词的内容,如果单词不存在则提示:
查无此词
1 # 2. 输入一些单词和解释,将单词作为键,将解释作为值,存入字典中 2 # 当输入单词或解释为空是停止输入,并打印这个字典 3 4 # 然后,输入查询的单词,给出单词的内容,如果单词不存在则提示: 5 # 查无此词 6 7 mydict = {} # 创建一个空字典准备存储数据 8 while True: 9 word = input("请输入单词: ") 10 if not word: # 如果word空字符串,则退出 11 break 12 trans = input("请输入解释: ") 13 if not trans: 14 break 15 # 走到此处,说明word, trans都绑定了正确的值 16 mydict[word] = trans 17 18 print("mydict=", mydict) 19 20 print("-------------以下开始查词--------") 21 while True: 22 w = input('请输入您要查询的单词: ') 23 if w in mydict: 24 print("解释是:", mydict[w]) 25 else: 26 print("查无此词!") 27 28
3. <<学生信息管理项目>>
输入任意个学生的姓名,年龄,成绩,每个学生的信息存入字典,然
后放入列表中,每个学生的信息需要手动输入,当输入姓名为空时
结束输入
如:
请输入姓名: tarena
请输入年龄: 20
请输入成绩: 99
请输入姓名: name2
请输入年龄: 18
请输入成绩: 88
请输入姓名: <回车> 结束输入
内部存储格式如下:
[{'name': 'tarena', 'age': 20, 'score':99},
{'name': 'name2', 'age': 18, 'score':88}]
打印上述此列表
然后再用表格的形式打印学生信息如下:
+---------------+----------+----------+
| 姓名 | 年龄 | 成绩 |
+---------------+----------+----------+
| tarena | 20 | 99 |
| name2 | 18 | 88 |
+---------------+----------+----------+
1 # student_info.py 2 # 3. <<学生信息管理项目>> 3 # 输入任意个学生的姓名,年龄,成绩,每个学生的信息存入字典,然 4 # 后放入列表中,每个学生的信息需要手动输入,当输入姓名为空时 5 # 结束输入 6 # 如: 7 # 请输入姓名: tarena 8 # 请输入年龄: 20 9 # 请输入成绩: 99 10 # 请输入姓名: name2 11 # 请输入年龄: 18 12 # 请输入成绩: 88 13 # 请输入姓名: <回车> 结束输入 14 # 内部存储格式如下: 15 # [{'name': 'tarena', 'age': 20, 'score':99}, 16 # {'name': 'name2', 'age': 18, 'score':88}] 17 # 打印上述此列表 18 # 然后再用表格的形式打印学生信息如下: 19 # +---------------+----------+----------+ 20 # | 姓名 | 年龄 | 成绩 | 21 # +---------------+----------+----------+ 22 # | tarena | 20 | 99 | 23 # | name2 | 18 | 88 | 24 # +---------------+----------+----------+ 25 26 L = [] # 创建一个列表,准备存放学生数据的字典 27 while True: 28 n = input("请输入姓名: ") 29 if not n: # 如果用户输入空字符串就结束输入 30 break 31 a = int(input("请输入年龄: ")) 32 s = int(input("请输入成绩: ")) 33 d = {} # 一定要每次都创建一个新的字典 34 d['name'] = n 35 d['age'] = a 36 d['score'] = s 37 L.append(d) # 把d加入列表中L 38 39 print(L) 40 41 42 print("+---------------+----------+----------+") 43 print("| 姓名 | 年龄 | 成绩 |") 44 print("+---------------+----------+----------+") 45 for d in L: 46 name = d['name'] 47 age = str(d['age']) # 转为字符串 48 score = str(d['score']) # 转为字符串 49 print("|%s|%s|%s|" % (name.center(15), 50 age.center(10), 51 score.center(10))) 52 53 # print("| tarena | 20 | 99 |") 54 # print("| name2 | 18 | 88 |") 55 print("+---------------+----------+----------+") 56