列表 list
问题：
容器
如何将计算运算的数据临时存在一个地方，同时又方便 添加，删除，修改等操作？
什么是列表：
列表是一种容器
列表是可以被改变序列
列表是由一系列特定元素组成的，元素与元素之间可能没有任何关联关系，但他们之间有先后顺序关系联关系，但他们之间有先后顺序关系
python3中序列类型简介：
字符串 str 列表 list 元组 tuple 字节串 bytes 字节数组 bytearray
创始空列表的字面值
L = [] # L绑定空列表
注： 表达式[] 会创建一个空的列表
创建非空列表的字面值
L = [1,2,3,4]
L = ["北京","上海","深圳"]
L = [1,"Two",3.14,"四"]
L = [1,2,[3.1,3.2],4]
列表的构造（创建）函数 list
list() # 创建一个空的列表，等同于[] list(iterable(可迭代)) # 用可迭代对象创建一个列表
# 示例： L = list() # L 绑定空列表等同于 L = [] L = list("hello") # L = ["h","e","l","l","o"] L = list(range(1,10,2)) # L = [1,3,5,7,9]
列表的运算
# 算术运算： + += * *=
# + 用于拼接列表 x = [1,2,3] y = [4,5,6] z = x+y # z = [1,2,3,4,5,6]
# += 将原列表与右侧的可迭代对象的数据追加，得到新的列表 # 语法： # x += 可迭代对象 # 如： x = [1,2,3] x += [4,5,6] x += "ABC" x += range(1,10,3) # 注： # += 运算符是用原可迭代对象的数据进行追加，原列表的ID不变
# 如：
s = "ABC"
print(id(s)) #???
s += "123"
print(id(s)) # 和上面的不相同
L = [1，2，3]
print(id(L)) #???
L = "123"
print(id(L)) # ???
# * 生成重复的列表 x = [1,2] * 3 # x = [1,2,1,2,1,2]
# *= 生成重复的列表，用原变量绑定更新后的列表 x = [1,2,3] x = 2 #[1,2,3,1,2,3]
列表的比较运算：
# 运算符： < <= > >= == !=
说明：
列表的比较规则与字符串的比较规则相同
列表要求每两个元素能依次进行比较，否则会出现类型错误
# 示例： [1,2,3] == [1,2,3] # True [1,2,3] != [1,3,2] # True [1,2,3] < [1,3,2] # True [1,2,3] >= [1,2] # True [1,"Two"] > ["Two",1] # TypeError （语法错误） [1,"two",3.14] < [1,"二",2.8] # True
列表是可迭代对象
L = [1,3,5,7] for x in L: print(x) # 打印 1 3 5 7
列表的 in / not in 运算符
判断一个值是否存在于列表中，如果存在返回True，否则返回False
（同字符串的in和not in 用法相同）
not in 返回值与in 相反
# 示例： x = [1,"Two",3,"四"] 3 in x #True "3" in x #False 10 in x #False 10 not in x #True
练习：
写一个程序，让用户输入很多个正整数，当输入负数时结束输入，将用户输入的数存于列表L中，打印这个列表
如：
请输入：1 请输入：2 请输入：3 请输入：4 请输入：-1
打印如下：
[1,2,3,4]
# L = [] x = int(input("请输入：")) L += [x] # 把x 放在列表中，追加到L的末尾
L =[] # 创建一个列表，准备存放数字 while True: # 每次输入一个数，如果次数小于0，则退出循环，否则把 # 这个数放在列表中 x= int(input("请输入：")) if x < 0: break L += [x] print("列表的内容是：",L)
列表的索引操作
语法：
列表[整数表达式]
用法：
等用于字符串的索引
索引分为正向索引和反向索引，规则写字符串索引规则完全相同
# 示例： 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:] = 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] l = [3,5]l[1:1] = [4]l[3:] = [6]l[len(l):] = [7] # 在长度最后一个插入l[0:0] =[1,2]print(l)
print(id(l))
#（2）将列表反转，删除最后一个元素后，打印此列表： # ... # print(L) #[6,5,4,3,2] # 将列表反转 l[::] = l[::-1] #ID 不变 del l[-1] print(l)
print("l=",id(l))
python3 中常用于序列的函数：
len(x) # 返回序列的长度
max(x) # 返回序列的最大值元素
min(x) # 返回序列的最小值元素
sum(x) # 返回序列中所有元素的和（元素必须是数值类型）(全部相加)
any(x) # 真值测试，如果列表中其中一个值为真值则返回True
all(x) # 真值测试，如果列表中所有值为真值才返回True，否则返回False
# 序列函数
reversed（seq） # 返回原序列反向顺序的可迭代对象
sorted（iterable,reverse=False） # 返回已排序的列表
# 示例： L = [8,3,6,2,7] print(len(L)) # 5 print(max(L)) # 8 print(min(L)) # 2 print(sun(L)) # 26 print(any(x)) # True print(all(x)) # True
# 示例： 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）打印你输入的这些数的平均值是多少？ l = []# 创建空列表 while True: n = int(input("请输入整数：")) if n == -1: break # 停止输入 l += [n] # 空列表加上转N列表 print("已输入：",l) print("你共输入了%d个有效的数："% len(l)) print("最大值是：",max(l)) print("最小值是：",min(l)) print("你输入的这些数的平均值是：",sum(l)/len(l))
# 2.写一个程序，让用户输入两个或以上的正整数，当输入小于零的数时结束输入（不允许输入重复的数） # 1）打印这些数的和 # 2）打印这些数的最大数 # 3）打印这些数的最二大的数 # 4）删除最小的一个数，并打原来的列表 l = [] # 创建一个容器，用变量来绑定 while True: n = int(input("请输入整数：")) if n < 0: if len(l)<2: print("请重新输入两次以上整数") continue break if n not in l: l += [n] print('和是：',sum(l)) l = sorted(l) print("最大数是",l[-1]) print("最二大数是：",l[-2])
i = l[0]
for x in range(len(l)):
if l[x] == i:
del l[x]
break
print(l)
python3 中常用的列表方法
# 方法 # 意义 L.index(v [, begin[, end]]) # 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误 L.insert(index, obj) # 将某个元素插放到列表中指定的位置 L.count(x) # 返回列表中元素的个数 L.remove(x) # 从列表中删除第一次出现在列表中的值 L.copy() # 复制此列表（只复制一层，不会复制深层对象) L.append(x) # 向列表中追加单个元素 L.extend(lst) # 向列表追加另一个列表 L.clear() # 清空列表,等同于 L[:] = [] L.sort(reverse=False) # 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列 L.reverse() # 列表的反转，用来改变原列表的先后顺序 L.pop([index]) # 删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系
练习：
# 练习： # 输入多行文字，存入列表中 # 每次输入后回车算作一行，任意输入多行文字 # 当直接输入回车（退空行时算作输入结果） # 要求： # 1）按原输入的内容在屏幕上输出内容 # 2）打印出你共输入了多少文文字 # 3）打印出你共输入了多少行字符 # 如： # 请输入：ABC # 请输入：abc # 请输入：123 # 请输入：《回车》 # 你输入的内容是： # ABC # abc # 123 # 你输入了3行文字 # 你输入了9个字符 l = [] while True: s = input("请输入：") if not s: # 当输用户直接输入回车时，得到空字符串 break l.append(s) # 将字符串s追加到l列表末尾 print(l) print("你输入的内容是：") for text in l: print(text) print("你输入了",len(l),"行文字") count = 0 for text in l: count += len(text) #把每一行字符串长度累加到count中 print("你输入两",count,"个字符")
深拷贝 和 浅拷贝
浅拷贝 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
# 深拷贝会在复制过程中，逐渐复制深层对象，实现两个对象的完全独立 # 如： # deepcopy 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() # 将字符串接换行符“\n” 分为分隔符进行分割返回分割后的列表 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) s2 = "-".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)
练习：
# 用列表推导式生成 1~ 100 内所有奇数组成的列表结果是：[1,3,5,7,......,99] # 示例： 生成一个数值为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]
练习：
# 用字符串"ABC"和"123" 生成如下列表： ["A1","A2","A3","B1","B2","B3","C1","C2","C3"] l = [x+y for x in "ABC" for y in "123"] print(l)
# 生成一个列表，此列表为x的平方加1不能被5整数的数的列表条件：（x ** 2 + 1） % 5 !=0 # x 的取值范围是：0<= x < 100 l = [x for x in range(0,100) if (x **2 + 1 )% 5 !=0] print(l)
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
