day05回顾
循环语句
for 语句
for 变量列表 in 可迭代对象:
语句块1
else:
语句块2
可迭代对象:
字符串str, range()返回的对象, 列表list
range(停止)
range(开始, 停止)
range(开始, 停止, 步长)
for语句嵌套
continue语句
列表 list
创建列表:
字面值
L = [1, 2, 3, 4]
[]
构造函数
list()
list(range(10))
list("ABC")
L2 = list(L) # 复制列表 L2 = L
列表的运算:
+ += * *=
< <= > >= == !=
in / not in 运算符
判断一个元素是否存在于列表
day06 笔记
列表的索引操作
语法:
列表[整数表达式]
用法:
等同于字符串的索引
索引分为正向索引和反向索引，规则与字符串索引规则完全相同
示例:
L = [1, 2, 3, 4]
print(L[1]) # 2
print(L[-1]) # 4
列表是可变的序列，列表支持索引赋值，列表可以通过索引赋值改变
列表中的元素
语法:
列表[整数表达式] = 表达式
示例:
L = [1, 2, 3, 4]
L[2] = 3.14 # 改变了第三个元素的值
列表的切片操作
取值:
列表[起始值:终止值]
列表[起始值:终止值:步长]
列表的切片取值返回一个列表，规则等同于字符串切片规则
示例:
L = list(range(10))
L2 = L[::2] # L2 = [0, 2, 4, 6, 8]
列表的切片赋值
作用:
可以改变源列表的排列，可以插入，修改和删除数据
语法:
列表[切片] = 可迭代对象
说明:
切片赋值的赋值运算符(=)的右侧必须是一个可迭代对象
示例:
L = [2, 3, 4]
L[0:1] = [1.1, 2.2] # L = [1.1, 2.2, 3, 4]
L[2:] = [3.3, 4.4, 5.5] # L = [1.1, 2.2, 3.3, 4.4, 5.5]
L[1:4] = [] # 切出2.2, 3.3, 4.4, 没加入新数据 L = [1.1, 5.5]
L[1:] = range(5, 9) # L = [1.1, 5, 6, 7, 8]
L = [2, 5]
L[1:1] = [3, 4] # L = [2, 3, 4, 5]
L[0:0] = range(2) # L = [0, 1, 2, 3, 4, 5]
L[6:] = [6, 7] # L = [0, 1, 2, 3, 4, 5, 6, 7]
切片注意事项:
对于步长不等于1的切片赋值，赋值运算符的右侧的可迭代对象提
供的元素的个数，一定要等于切片切出的段数
L = [1, 2, 3, 4, 5, 6]
L[::2] = "ABC" # 对的
L[::2] = "ABCDE" # 错的
del 语句用于删除列表的元素
语法:
del 列表[索引] # 删除索引
del 列表[切片] # 删除切片
示例:
L = [1, 2, 3, 4, 5, 6, 7]
del L[-1] # L = [1, 2, 3, 4, 5, 6]
del L[::2] # L = [2, 4, 6]
练习:
已知有列表:
L = [3, 5]
1) 用索引和切片操作，将原列表改变为:
L = [1, 2, 3, 4, 5, 6]
2) 将列表反转，删除最后一个元素后，打印此列表:
...
print(L) # [6, 5, 4, 3, 2]
1 # 练习: 2 # 已知有列表: 3 # L = [3, 5] 4 # 1) 用索引和切片操作，将原列表改变为: 5 # L = [1, 2, 3, 4, 5, 6] 6 # 2) 将列表反转，删除最后一个元素后，打印此列表: 7 # ... 8 # print(L) # [6, 5, 4, 3, 2] 9 10 L = [3, 5] 11 12 print("id(L)", id(L)) # ?????? 13 L[1:1] = [4] # L = [3, 4, 5] 14 L[len(L):] = [6] 15 L[0:0] = [1, 2] 16 print('L=', L) 17 18 # 将列表反转，删除最后一个元素后，打印此列表: 19 # L = L[::-1] # <<<<------ L绑定新的列表ID会变化 20 L[::] = L[::-1] # ID不变 21 del L[-1] 22 print("L=", L) 23 print("id(L):", id(L)) 24 25 26
Python3 中常用于序列的函数:
len(x) 返回序列的长度
max(x) 返回序列的最大值元素
min(x) 返回序列的最小值元素
sum(x) 返回序列中所有元素的和(元素必须是数值类型)
any(x) 真值测试,如果列表中其中一个值为真值则返回True
all(x) 真值测试,如果列表中所有值为真值才返回True,否则
返回False
示例:
L = [8, 3, 6, 2, 7]
print(len(L)) # 5
print(max(L)) # 8
print(min(L)) # 2
print(sum(L)) # 26
print(any(x)) # True
print(all(x)) # True
序列函数2
reversed(seq) 返回原序列反向顺序的可迭代对象
sorted(iterable, reverse=False) 返回已排序的列表
示例:
L = [1, 2, 3, 4]
for x in L:
print(x) # 1 2 3 4
for x in reversed(L):
print(x) # 4 3 2 1
L2 = [5, 8, 3, 7, 1]
L3 = sorted(L2) # L3 = [1, 3, 5, 7, 8]
L4 = sorted(L2, reverse=True) # 降序排序 L4=[8,7,5,3,1]
练习:
1. 写程序,让用户循环输入一些正整数.当输入-1时结束输入,将
这些整数存于列表L中.
1) 打印出您共输入了几个有效的数(不算结束的-1)
2) 打印您输入的最大数是多少?
3) 打印您输入的最小数是多少?
4) 打印您输入的这些数的平均值是多少?
2. 写一个程序,让用户输入两个或以上的正整数,当输入小于零的数
时结束输入(不允许输入重复的数)
1) 打印这些数的和
2) 打印这些数的最大数
3) 打印这些数的最二大的数
4) 删除最小的一个数,并打印原来的列表
1 # 2. 写一个程序,让用户输入两个或以上的正整数,当输入小于零的数 2 # 时结束输入(不允许输入重复的数) 3 # 1) 打印这些数的和 4 # 2) 打印这些数的最大数 5 # 3) 打印这些数的最二大的数 6 # 4) 删除最小的一个数,并打印原来的列表 7 8 numbers = [] # 创建一个容器,用变量numbers绑定 9 while True: 10 x = int(input("请输入正整数: ")) 11 if x < 0: 12 if len(numbers) < 2: 13 print('您输入的数字太少') 14 continue 15 break 16 if x not in numbers: 17 numbers += [x] 18 19 print("这些数的和是:", sum(numbers)) 20 L = sorted(numbers) 21 print("最大数是:", L[-1]) 22 print("第二大数是:", L[-2]) 23 min_number = L[0] 24 for i in range(len(numbers)): 25 if numbers[i] == min_number: 26 del numbers[i] 27 break 28 29 print("删除最小数后的列表是: ", numbers) 30
python3 中常用的列表方法
文档参见:
python_base_docs_html/list.py
练习:
输入多行文字,存入列表中
每次输入后回车算作一行,任意输入多行文字.
当直接输入回车(即空行时算作输入结束)
要求:
1) 按原输入的内容在屏幕上输出内容
2) 打印出您共输入了多少行文字
3) 打印出您共输入了多少个字符
如:
请输入: ABC
请输入: abc
请输入: 123
请输入: <回车>
您输入的内容是:
ABC
abc
123
您输入了3行文字
您输入了9个字符
1 # 练习: 2 # 输入多行文字,存入列表中 3 # 每次输入后回车算作一行,任意输入多行文字. 4 # 当直接输入回车(即空行时算作输入结束) 5 # 要求: 6 # 1) 按原输入的内容在屏幕上输出内容 7 # 2) 打印出您共输入了多少行文字 8 # 3) 打印出您共输入了多少个字符 9 # 如: 10 # 请输入: ABC 11 # 请输入: abc 12 # 请输入: 123 13 # 请输入: <回车> 14 # 您输入的内容是: 15 # ABC 16 # abc 17 # 123 18 # 您输入了3行文字 19 # 您输入了9个字符 20 21 22 L = [] 23 24 while True: 25 s = input("请输入: ") 26 if not s: # 当输用户直接输入回车时,得到空字符串 27 break 28 L.append(s) # 将字符串s追加到L列表末尾 29 print("L=", L) 30 print("您输入的内容是:") 31 for text in L: 32 print(text) 33 34 print("您输入了", len(L), '行文字') 35 36 count = 0 37 for text in L: 38 count += len(text) # 把每一行字符串长度累加到count中 39 print("您输入了", count, '个字符') 40
深拷贝 和 浅拷贝
浅拷贝 shallow copy
浅拷贝是指在复制过程中,只复制一层变量,不会复制深层变量绑定的
对象的复制过程
如:
L1 = [1, 2, [3.1, 3.2]]
L2 = L1.copy()
L2[2][0] = 3.14
print(L1) # [1, 2, [3.14, 3.2]]
print(L2) # [1, 2, [3.14, 3.2]]
深拷贝 deep copy
深拷贝会在复制过程中,逐层复制深层对象,实现两个对象的完全独立
如:
import copy # 导入考拷贝模块
L1 = [1, 2, [3.1, 3.2]]
L2 = copy.deepcopy(L1)
L2[2][0] = 3.14
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) # [1, 2, [3.14, 3.2]]
小结:
L1 = [1, 2, [3.1, 3.2]]
L2 = L1 # 不拷贝
L3 = L1.copy() # 浅拷贝
import copy
L4 = copy.deepcopy(L1) # 深拷贝
列表与字符串比较:
列表和字符串都是序列,元素之间有先后关系
字符串中每个元素只能存储字符,而列表可以存储任意类型的元素
字符串是不可变的序列,而列表是可变的序列
列表和字符串都是可迭代对象
字符串的文本解析方法
方法名 说明
S.split(sep=None) 将字符串,使用sep作用分隔符分割S字符串
返回分割后的字符串列表,当不给定参数时,用空白字符
作为分隔符
S.splitlines() 将字符串接换行符'
' 分为分隔符进行分割
返回分割后的列表
S.join(iterable) 用可迭代对象中的字符串,返回一个是中间
用S进行分隔的字符串
示例:
s = 'Beijing is capital'
L = s.split() # L = ['Beijing', 'is', 'capital']
s2 = '-'.join(L) # s2 = 'Beijing-is-capital'
练习:
有字符串'hello' 生成字符串'h e l l o' 和 'h-e-l-l-o'
答案:
s = 'hello'
s2 = ' '.join(s)
s3 = '-'.join(s)
创建列表的方法有几种:
字面值:
[1, 2, 3]
构造函数:
list(range(1, 4))
列表推导式方式
列表推导式 list comprehension
列表推导式是用可迭代对象创建列表的表达式
作用:
用简易方法生成列表
语法:
[表达式 for 变量 in 可迭代对象]
或
[表达式 for 变量 in 可迭代对象 if 真值表达式]
示例:
生成一个数值为1~9的整数的平方的列表,如:
L = [1, 4, 9, 16, 25, 36, 49, 64, 81]
用循环语句:
L = []
for x in range(1, 10):
L.append(x ** 2)
L = [x ** 2 for x in range(1, 10)]
练习 :
用列表推导式生成 1~100 内所有奇数组成的列表
结果是:[1, 3, 5, 7, ....., 99]
1 # 练习 : 2 # 用列表推导式生成 1~100 内所有奇数组成的列表 3 # 结果是:[1, 3, 5, 7, ....., 99] 4 5 # L = [x for x in range(1, 100, 2)] 6 L = [x for x in range(1, 100) if x % 2 == 1] 7 print(L) 8 9 L = [] 10 for x in range(1, 100): 11 if x % 2 == 1: 12 L.append(x) 13 print("L=", L)
示例:
生成一个数值为1~9的奇数的平方的列表,如:
L = [1, 9, 25, 49, 81]
L = [x**2 for x in range(1, 10) if x % 2 == 1]
列表推导式的嵌套:
语法:
[表达式 for 变量1 in 可迭代对象1 if 真值表达式1
for 变量2 in 可迭代对象2 if 真值表达式2
...]
示例:
将列表[10, 20, 30] 中的元素与列表[1, 2, 3] 元素分别相
加,将得到的元素放于一个列表中...
L = [x + y for x in [10,20,30] for y in [1,2,3]]
print(L) # [11, 12, 13, 21, 22, 23, 31, 32, 33]
1. 练习:
用字符串"ABC" 和 "123 生成如下列表:
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
2. 生成一个列表,此列表为x的平方加1不能被5整数的数的列表
条件: (x ** 2 + 1) % 5 != 0
x的取值范围是: 0 <= x < 100
L = [x for x in range(100) if (x ** 2 + 1) % 5 != 0]
1 # 练习 : 2 # 用列表推导式生成 1~100 内所有奇数组成的列表 3 # 结果是:[1, 3, 5, 7, ....., 99] 4 5 # L = [x for x in range(1, 100, 2)] 6 L = [x for x in range(1, 100) if x % 2 == 1] 7 print(L) 8 9 L = [] 10 for x in range(1, 100): 11 if x % 2 == 1: 12 L.append(x) 13 print("L=", L)
练习:
1. 已知有一个字符串:
s= '100,200,300,500,800'
将其转化为列表,列表内都为整数,即:
L = [100,200,300,500,800]
2. 有一些数存于列表中,如:
L = [1, 3, 2, 1, 6, 4, 2, ....., 98, 82]
1) 将列表中出现数字存入到另一个列表L2中
要求:
重复出现多次的数只在L2列表中保留一份(去重)
2) 将列表中出现两次的数字存于L3列表中,在L3列表中只保留一份
3. 生成前40个斐波那契数(Fibonacci)
1 1 2 3 5 8 13 21
要求: 将这些数保存在列表中,最后打印这些数
注: 斐波那契数的前2个数为1 和 1, 从第二个数起为前两个
数相加之和
1 # 3. 生成前40个斐波那契数(Fibonacci) 2 # 1 1 2 3 5 8 13 21 3 # 要求: 将这些数保存在列表中,最后打印这些数 4 # 注: 斐波那契数的前2个数为1 和 1, 从第二个数起为前两个 5 # 数相加之和 6 7 # 方法1: 8 # L = [] 9 # a = 0 # a表示第一个数的前一个数 10 # b = 1 # b表示第一个数 11 # while len(L) < 40: 12 # # 每次把b加入到列表中 13 # L.append(b) 14 # # 再算出下一个fibonacci数，存于b中 15 # c = a + b # 算出下一个数 16 # a = b # 把当前作为前一个数 17 # b = c # 把新算出来的c交给b 18 19 # 方法2 20 # L = [] 21 # a = 0 # a表示第一个数的前一个数 22 # b = 1 # b表示第一个数 23 # while len(L) < 40: 24 # # 每次把b加入到列表中 25 # L.append(b) 26 # # 再算出下一个fibonacci数，存于b中 27 # a, b = b, a + b # 序列赋值 28 # # c = a + b # 算出下一个数 29 # # a = b # 把当前作为前一个数 30 # # b = c # 把新算出来的c交给b 31 32 # 方法3 33 L = [1, 1] 34 while len(L) < 40: 35 # 每次生成一个数，加到列表里 36 L.append(L[-1] + L[-2]) 37 38 39 print("L=", L) 40 41 42 43 44 45 46 47 48 49 50 51 52 53
1 # 1. 已知有一个字符串: 2 # s= '100,200,300,500,800' 3 # 将其转化为列表,列表内都为整数,即: 4 # L = [100,200,300,500,800] 5 6 7 s= '100,200,300,500,800' 8 L2 = s.split(',') # L2=['100','200','300','500','800'] 9 L = [int(x) for x in L2] 10 11 print("L=", L) # print("L=", str(L)) 12
1 # 2. 有一些数存于列表中,如: 2 # L = [1, 3, 2, 1, 6, 4, 2, ....., 98, 82] 3 # 1) 将列表中出现数字存入到另一个列表L2中 4 # 要求: 5 # 重复出现多次的数只在L2列表中保留一份(去重) 6 # 2) 将列表中出现两次的数字存于L3列表中,在L3列表中只保留一份 7 8 9 L = [1, 3, 2, 1, 6, 4, 2, 98, 82] 10 L2 = [] 11 for x in L: 12 if x not in L2: # 说明L2里不存在，这是第一次出现 13 L2.append(x) 14 print('L2 =', L2) 15 16 # 2) 将列表中出现两次的数字存于L3列表中,在L3列表中只保留一份 17 L3 = [] 18 for x in L: 19 if L.count(x) == 2 and x not in L3: 20 L3.append(x) 21 print("L3=", L3) 22 23 24 25