什么是列表?为什么需要使用列表?

  • 变量可以储存一个数据,而列表可以储存N个不同类型的数据,方便系统管理和调用(相当于书包放着N本书籍和笔本子等物品,你可以随时拿出要使用的物品)
  • 列表可以存储重复的数据
  • 每一个数据都有一个正序索引和一个倒序索引
  • 用列表存储数据可以节省内存使用
  • 列表是可迭代对象,可以被遍历(测试发现,可迭代对象,列表,字符串等,每次运行都会被重新赋予新的标识ID
  • 列表相当于其他计算机语言中的数组
  • 列表示意图
正序索引0123456
数据'hello''world'95.834'world'34'world'
倒序索引-7-6-5-4-3-2-1

列表的创建:

  1. 使用方括号[]包裹数据,用,逗号分隔数据
  2. 使用内置函数list()包裹方括号[]再包裹数据,用,逗号分隔数据
list1 = ['hello', 123, 95.8]
list2 = list(['hello', 123, 95.8])
print('标识', id(list1))
print('类型', type(list1))
print('值', list1)

运行结果:

  • 标识 31191488
  • 类型 <class 'list'>
  • ['hello', 123, 95.8]

列表有自己单独的标识ID,数据类型为list,值就是列表里面的所有数据,一般用第一种创建方式简单些

列表的数据也可以一次赋值给多个相等数量的变量(系列解包赋值)

a, i, k = list([1, 2, 3])
print(a, i, k)
b, c, d = [1, 2, 3]
print(b, c, d)

运行结果:

  • 1 2 3
  • 1 2 3

左边的变量数和右边列表的数据数量必须相等,不然无法完成系列解包赋值

列表的输出是按顺序来的,可以按序号(正负都可以)来输出对应的数据

lst = [10, 20, 30, 40, 50]
print(lst)
print(lst[0])  # 正序号0 ~ N-1,例如:整数40是第4个数据,但它的索引是3
print(lst[-3])  # 负序号-1 ~ -N
# print(lst[6])  # IndexError: list index out of range(列表索引超出范围)

运行结果:

  • [10, 20, 30, 40, 50]
  • 10
  • 30

完整的输出列表直接输出列表变量名就好,要单独输出数据需要在列表变量后面加方括号[],然后方括号里面写对应的序号,例如:列表变量lst中,正序索引序号0代表的是整数10这个数据,倒序索引序号-3代表的是整数30这个数据,具体参考上面的列表示意图。当索引的序号在列表中不存在时,会报错

查询列表中数据的索引序号

lst = [10, 20, 30, 40, 30, 50]
print(lst.index(30))
# print(lst.index(60))  # ValueError: 60 is not in list(60在列表中不存在)

运行结果:

  • 2

可以在列表变量后面加.index(),括号内是需要查询的数据,整数30在列表对象lst中的正序索引为序号2,所以返回值为2,也说明.index()返回的是正序索引,而且整数30在列表对象lst中存在重复,返回的是正序索引中从小到大的顺序的第一个30的序号,说明当查询的数据在列表中存在重复数据时,只返回第一个的序号,当查询的元素在列表中不存在时,会报错

可以从指定的索引区间查找数据

lst = [10, 20, 30, 40, 30, 50]
print(lst.index(30, 3, 5))  # 第一个值代表要查询的数据,第二个值是索引开始的位置,
# 第三个值是索引结束的位置(不包括结束值)
# print(lst.index(30, , 5))  # SyntaxError: invalid syntax(无效语法)

运行结果:

  • 4

如上述注释,查询的起始位置为序号3,代表的数据为40,结束位置为序号5,但不会包括5,也就是说真正的结束位置是序号4,代表的数据为30,所以就是在数据4030中查询30代表的序号,所以返回值为4,实测发现,索引结束的位置可以不写,代表从索引开始的位置直接索引到最后,在设置了索引结束位置的情况下,不能不填写索引开始的位置,会报错

列表切片

可以将原列表裁取部分进行输出或者赋值给新变量

lst = [10, 20, 30, 40, 50, 60, 70, 80]
print(lst[0:5:1])  # 直接输出切片部分的列表
lst2 = lst[0:5:1]  # 第一个值为索引开始位置,第二个值为索引结束位置,第三个值为索引的步长
# (也就是隔几个索引位置获取一个数据由步长决定)
print(lst2)  # 将切片部分赋值给新变量,然后输出新的列表变量
print(id(lst), id(lst2))

运行结果:

  • [10, 20, 30, 40, 50]
  • [10, 20, 30, 40, 50]
  • 37941824 37942400

可以看出,新的列表和原列表标识ID是不同的,切片的索引用冒号:隔开,索引开始位置不填写默认为最左侧开始,索引结束位置不填写默认为最右侧结束并包含最后一个数据,步长不填写默认为1

正序切片和倒序切片

lst = [10, 20, 30, 40, 50, 60, 70, 80]
lst1 = lst[::1]
lst2 = lst[::-1]
print(lst1)
print(lst2)

运行结果:

  • [10, 20, 30, 40, 50, 60, 70, 80]
  • [80, 70, 60, 50, 40, 30, 20, 10]

是正序切片还是倒序切片由步长的正负来决定,步长为正数,就是正序切片,反之就是倒序切片,看上面的代码,我们把索引开始位置和索引结束位置都空出来了,代表不限制索引位置,引用整个列表,看最后的返回值可以看出在倒序切片中,索引开始位置为列表中最右边的数据,索引结束位置为列表中最左边的数据,这跟开始的列表示意图概念相同

如果设定了索引结束位置,那么不管是正序切片还是倒序切片,都不会包含结束序号所代表的数据

lst = [10, 20, 30, 40, 50, 60, 70, 80]
lst1 = lst[1:7:1]
lst2 = lst[-2:-8:-1]
print(lst1)
print(lst2)

运行结果:

  • [20, 30, 40, 50, 60, 70]
  • [70, 60, 50, 40, 30, 20]

17代表的是20,30,40,50,60,70,80,因为不包含7,所以是20,30,40,50,60,70-2-8代表的是70,60,50,40,30,20,10,因为不包含-8,所以是70,60,50,40,30,20

设置索引开始位置和索引结束位置的时候需要根据切片是正序还是倒序来设定,不然可能会出现返回空列表

lst = [10, 20, 30, 40, 50, 60, 70, 80]
a = lst[6:-1:-1]  # 开始序号6为70,结束序号-1为80,70到80是从左到右,步长-1为倒序切片
b = lst[5:7:-1]  # 开始序号5为60,结束序号7为80,60到80是从左到右,步长-1为倒序切片
c = lst[6:3:1]  # 开始序号6为70,结束序号3为40,70到40是从右到左,步长1为正序切片
d = lst[-2:2:1]  # 开始序号-2为70,结束序号2为30,70到30是从右到左,步长1为正序切片
e = lst[2:2:1]
f = lst[2:2:-1]
print(a, b)
print(c, d)
print(e, f)

运行结果:

  • [] []
  • [] []
  • [] []

从上面代码和返回结果看出,在倒序切片中,如果我们设定的索引开始和结束位置所代表的数据排列顺序为从左到右,返回值会是空列表,为什么会这样?看上面实测,倒序切片默认的索引开始位置到结束位置的顺序为从右到左,而我们设定的索引顺序刚好相反,这时候切片从索引开始位置右向左则没有数据可遍历,所以返回空列表,正序切片则正好相反,还有一种情况,如果设定的索引开始位置和结束位置序号代表的数据是同一个,因为不会包含结束序号所代表的数据,所以这段索引其实没有获取任何数据,最终不管是正序切片还是倒序切片,返回值都是空列表

可以使用布尔运算符innot in来判断数据是否在列表中存在

lst = [10, 20, 30, 'python', 32.9]
a = 'python'
print(32.9 in lst)
print('python' not in lst)
print('p' in lst)
print('p' in a)

运行结果:

  • True
  • False
  • False
  • True

可迭代对象都可以用布尔运算符innot in来判断数据是否在其中,第二行代码用字符串做示例,字符'p'在字符串变量a中存在,且第六行代码返回值为True,证实了这一点,列表变量lst中也有字符串'python',但第五行代码最终判断返回值为False,这是因为列表内的对象都是独立存在的,不可以被再拆分遍历(例如字符'p'在列表中其实是存在的,但列表中的字符串对象'python'是一个整体,不可以被拆分遍历,所以返回值为False

列表可以作为可迭代对象用作for...in...循环

lst = [10, 20, 30, 'python', 32.9]
for a in lst:
    print(a)

运行结果:

  • 10
  • 20
  • 30
  • python
  • 32.9

列表元素的添加操作

  • append() 在列表的末尾添加一个元素
  • extend() 在列表的末尾至少添加一个元素
  • insert() 在列表的任意位置添加一个元素
  • 切片 在列表的任意位置添加至少一个元素

append()

在指定的列表对象末尾添加一个元素,这个元素可以是直接的数据,也可以是包含数据的变量,但括号内只能填写一个元素

lst = [10, 20, 30]
print(lst)
lst.append(50)
print(lst)
a = [100, 200]
lst.append(a)
print(lst)

运行结果:

  • [10, 20, 30]
  • [10, 20, 30, 50]
  • [10, 20, 30, 50, [100, 200]]

使用方法,在列表变量名后面加.append(),括号内填写要添加进列表末尾的元素,第一次直接添加整数50进列表,列表从[10, 20, 30]变成[10, 20, 30, 50],添加进去的元素成了列表最末尾的数据,第二次我们添加一个列表变量a进列表,虽然列表对象[100, 200]中包含了两个数据,但它们属于一个列表对象,所以第二次用.append()添加后,列表从[10, 20, 30, 50]变成[10, 20, 30, 50, [100, 200]],直接把整个列表对象[100, 200]添加到列表最末尾成为一个独立的数据,说明append()可以添加一个元素到列表末尾,这个元素可以是一个整数,一个字符串,一个列表,一个元组,等等...

extend()

在指定的列表对象末尾添加至少一个元素,这个元素只可以是一个字符串或者列表等可迭代对象,记住,括号内只能填写一个字符串或者列表等可迭代对象,也可以是包含数据的变量,如果变量只包含一个字符串或者列表等可迭代对象,是字符串的话,会被拆分成一个个字符按原顺序添加到指定的列表末尾,是列表的话,会被拆分成一个个数据按原顺序添加到指定的列表末尾,如果变量包含的是多种类型数据的元组或者列表,都只会去掉外层的元组或者列表

lst = [10, 20, 30]
print(lst)
lst.extend('123')
print(lst)
a = '111', [10, 20], 123  # '111', [10, 20], 123 和 ('111', [10, 20], 123) 是相同的意思,都表示元组
lst.extend(a)
print(lst)
b = ['111', [10, 20], 123]
lst.extend(b)
print(lst)

运行结果:

  • [10, 20, 30]
  • [10, 20, 30, '1', '2', '3']
  • [10, 20, 30, '1', '2', '3', '111', [10, 20], 123]
  • [10, 20, 30, '1', '2', '3', '111', [10, 20], 123, '111', [10, 20], 123]

使用方法,在列表变量名后面加.extend(),括号内填写要添加进列表末尾的元素,第一次直接添加字符串'123'进列表,根据上面所述要求,列表从[10, 20, 30]变成[10, 20, 30, '1', '2', '3'],字符串被拆分成单独的字符按原顺序添加到了列表的末尾,第二次我们添加一个元组变量a进列表,元组对象'111', [10, 20], 123有三个数据,都是不同类型的,但他们同属于一个元组对象,所以被去掉外层的元组后,列表从[10, 20, 30, '1', '2', '3']变成[10, 20, 30, '1', '2', '3', '111', [10, 20], 123],外层元组被拆开,三个数据按原顺序添加到了列表的末尾,第三次我们添加列表变量b,列表从[10, 20, 30, '1', '2', '3', '111', [10, 20], 123]变成[10, 20, 30, '1', '2', '3', '111', [10, 20], 123, '111', [10, 20], 123],同样,外层列表被拆开,三个数据按原顺序添加到了列表的末尾,和append()不同的是,extend()会拆开外层的列表或者元组等,将里面的数据一个个添加到列表末尾,而append()却会把元组或者列表等可迭代对象作为一个整体添加到列表末尾

insert()

在列表的任意指定位置添加一个元素

lst = [10, 20, 30]
print(lst)
lst.insert(1, 15)
print(lst)

运行结果:

  • [10, 20, 30]
  • [10, 15, 20, 30]

使用方法,在列表变量名后面加.insert(),括号内可以填写两个参数,用分隔符,隔开,第一个参数为列表序号,代表要添加元素的位置,添加后,原列表数据中从添加位置开始的数据往后移动一个位置,新添加的数据成为指定序号所代表的数据。第二个参数为要添加的元素,可填写的元素与上面append()中可填写的元素相同。看代码,在insert()括号内输入参数(1, 15)后,代表要在原列表中序号1的位置添加一个整数15的数据,列表从[10, 20, 30]变成[10, 15, 20, 30]2030原来的序号是12,添加后,变成了23,这就是我所表达的原数据从添加位置开始往后移动一个位置

切片添加

在列表的任意指定位置添加至少一个元素

lst = [10, 20, 30, 40, 50, 60, 70, 80]
print(lst)
a = '111', [10, 20], 123
lst[2:5] = a
print(lst)

运行结果:

  • [10, 20, 30, 40, 50, 60, 70, 80]
  • [10, 20, '111', [10, 20], 123, 60, 70, 80]
lst = [10, 20, 30, 40, 50, 60, 70, 80]
print(lst)
lst[2:8:2] = '111', [10, 20], 123
print(lst)

运行结果:

  • [10, 20, 30, 40, 50, 60, 70, 80]
  • [10, 20, '111', 40, [10, 20], 60, 123, 80]

使用方法,在列表变量名后面加方括号[],里面可以填写三个参数,用冒号:隔开,第一个为列表切片开始位置的序号,第二个为列表切片结束位置的序号,第三个位置为列表切片的步长(隔几个位置切掉一个数据),右边为要添加的元素,用赋值运算符赋值给列表切片位置,相当于替换掉了切片位置的数据,可填写的元素与上面extend()中可填写的元素相同,可以是包含数据的变量,也可以不通过变量直接写数据,例如元组和列表或者字符串,如果不填写步长参数,切片开始与结束位置数据的个数和替换数据的个数可以不相等,如果填写步长参数,那么切片开始与结束位置数据的个数除去步长的间隔后至少要和替换数据的个数相等或者比之更多。

看第一段代码,切片参数为[2:5],除去序号5,也就是序号为2,3,4的列表数据被替换,列表从[10, 20, 30, 40, 50, 60, 70, 80]变成[10, 20, '111', [10, 20], 123, 60, 70, 80],看第二段代码,切片参数为[2:8:2],除去序号8,也就是序号为2,3,4,5,6,7的列表数据被替换,然后步长为2,最终序号为2,4,6的列表数据被替换,用来替换的元组中正好是3个数据,与之相等,成立,列表从[10, 20, 30, 40, 50, 60, 70, 80]变成[10, 20, '111', 40, [10, 20], 60, 123, 80]

列表元素的删除操作

  • remove() 删除一个指定的列表元素
  • pop() 删除指定索引上的列表元素
  • 切片 删除指定序号段的列表元素
  • clear() 清空列表元素
  • del 删除列表

remove()

按照设定的元素删除对应的列表元素,一次只删除一个元素,重复的元素只删除从左到右顺序的第一个,元素不存在的话会提示错误

lst = [10, 20, 30, 40, 50, 60, 70, 30]
print(lst)
lst.remove(30)
print(lst)

运行结果:

  • [10, 20, 30, 40, 50, 60, 70, 30]
  • [10, 20, 40, 50, 60, 70, 30]

使用方法,在列表变量名后面加上.remove(),括号内填写要删除的元素,看上面代码,指定删除的元素为整数30,而列表里面有两个为整数30的元素,按上述规则,重复元素删除从左到右顺序的第一个,运行后,列表从[10, 20, 30, 40, 50, 60, 70, 30]变成[10, 20, 40, 50, 60, 70, 30]

pop()

按照设定的索引序号,删除对应的列表元素,不指定索引,也就是括号内为空的话,会删除列表末尾的元素,指定的索引序号在列表中不存在的话,会提示错误

lst = [10, 20, 30, 40, 50, 60, 70, 30]
print(lst)
lst.pop(3)
print(lst)
lst.pop()  # pop括号内不指定参数的话,默认删除最后一个列表元素
print(lst)

运行结果:

  • [10, 20, 30, 40, 50, 60, 70, 30]
  • [10, 20, 30, 50, 60, 70, 30]
  • [10, 20, 30, 50, 60, 70]

使用方法,在列表变量名后面加上.pop(),括号内填写要删除的元素对应的索引序号,看上面代码,第一次指定的索引序号为3,对应的列表元素为整数40,运行后,列表从[10, 20, 30, 40, 50, 60, 70, 30]变成[10, 20, 30, 50, 60, 70, 30],第二次指定的索引序号为空,根据上述规则,括号内为空则默认删除列表最后一个元素(从左到右顺序最后一个),运行后,列表从[10, 20, 30, 50, 60, 70, 30]变成[10, 20, 30, 50, 60, 70]

切片删除

按照设定的索引序号片段,删除一个或者多个列表元素

lst = [10, 20, 30, 40, 50, 60, 70, 30]
print(lst)
lst[1:4] = []  # 切片删除方式就是用空列表代替切片的位置
print(lst)

运行结果:

  • [10, 20, 30, 40, 50, 60, 70, 30]
  • [10, 50, 60, 70, 30]

跟切片添加的使用方法和原理一样,只不过后面替换的对象变成了空列表,用空列表替换指定的列表元素片段,就相当于删除了指定的列表元素片段,不过切片的步长只能为默认的1,不然会提示错误,因为一个空列表只能替换一个列表元素片段,当步长为2或者2以上的时候,切片中元素之间有了间隔,就变成了多个列表元素片段,一个空列表无法替换多个列表元素片段,所以提示错误,看上面代码,切片[1:4]代表的索引序号为1,2,3,不包含4,也就是相应的列表元素整数20,30,40被替换,列表从[10, 20, 30, 40, 50, 60, 70, 30]变成[10, 50, 60, 70, 30]

lst = [10, 20, 30, 40, 50, 60, 70, 30]
print(lst)
lst[1:4:2] = []
print(lst)

运行结果:

  • [10, 20, 30, 40, 50, 60, 70, 30]
  • ValueError: attempt to assign sequence of size 0 to extended slice of size 2错误提示

替换对象只有一个空列表,切片[1:4:2]代表的索引序号为1,3,中间有间隔,需要两个替换对象才能替换,所以无法替换,提示错误

lst = [10, 20, 30, 40, 50, 60, 70, 30]
print(lst)
lst[1:4:2] = [], []
print(lst)

运行结果:

  • [10, 20, 30, 40, 50, 60, 70, 30]
  • [10, [], 30, [], 50, 60, 70, 30]

看代码,这样其实是一个元组包含了两个空列表,两个空列表替换到两个列表元素片段,但这样不算删除了,因为只能去掉外层的元组,所以整个空列表被替换进来,而不是空列表里面的空白

clear()

清空列表里面的所有元素

lst = [10, 20, 30, 40, 50, 60, 70, 30]
print(lst)
lst.clear()  # 清空列表里面的元素
print(lst)

运行结果:

  • [10, 20, 30, 40, 50, 60, 70, 30]
  • []

使用方法,在列表变量名后面加上.clear(),括号内无需填写,直接清空这个列表里面所有的元素,使其变为一个空列表

del

直接删除指定的列表

lst = [10, 20, 30, 40, 50, 60, 70, 30]
print(lst)
del lst
print(lst)

运行结果:

  • [10, 20, 30, 40, 50, 60, 70, 30]
  • NameError: name 'lst' is not defined错误提示

使用方法,del+空格+列表变量名,直接删除对应的列表,使其变得不存在,所以后面再输出这个列表会提示此列表未定义(不存在)

remove()的实操小案例

a = [1, 1, 3, 4, 5]
for b in a:
    a.remove(b)
print(a)

运行结果:

  • [1, 4]

看上面代码,看前面所学知识,列表对象a的元素一个个赋值给变量b,然后列表对象a通过remove()一次次将变量b对应的列表元素删除掉,最后运行结果应该是一个空列表,但最后却得到了一个[1, 4]的新列表,下面看解析

原理:

for...in...循环记录到变量a包含的列表有5个元素,也就是可以循环5次,第一次循环的时候,赋值给变量b的值为整数1,运行一次remove后,列表元素内第一个整数1被删除了,这时列表内剩下[1, 3, 4, 5]四个元素,然后第二次循环开始,也正是因为进入了第二次循环,系统默认将第二个元素,整数3赋值给了变量b,整数3被删除后,列表内剩下[1, 4, 5]三个元素,然后第三次循环整数5被赋值给变量b,第三次循环结束后,系统识别到刚已经遍历到列表的最后一个元素,停止遍历,不再进行第四次循环,结束循环,所以最后列表内[1, 4]两个元素被保存下来

列表元素的修改操作

  • 指定索引修改一个元素
  • 切片,一次修改至少一个元素

指定索引修改单个元素

lst = [10, 20, 30, 40, 50]
print(lst)
lst[2] = 100
print(lst)

运行结果:

  • [10, 20, 30, 40, 50]
  • [10, 20, 100, 40, 50]

使用方法跟切片一样,不同的是方括号[]内只需要填写一个索引序号,然后新的元素通过赋值运算符替换掉指定的索引元素,上面代码索引序号为2,对应列表里面的元素整数30,运行后,列表从[10, 20, 30, 40, 50]变成[10, 20, 100, 40, 50]

切片修改

跟上面列表元素的添加操作里面的切片添加操作和原理都一样,不再做解析

列表的排序操作

  • sort() 调用函数再原列表基础上修改排序
  • sorted() 内置函数,修改原列表排序后赋值给新变量或者直接输出

sort()

默认进行从小到大的升序排序,可以调用参数进行降序排序

lst = [10, 50, 60, 12, 98.5, 30]
print('原列表', lst)
lst.sort()
print('默认升序排序后', lst)
lst.sort(reverse=False)
print('调用参数升序排序后', lst)
lst.sort(reverse=True)
print('调用参数降序排序后', lst)

运行结果:

  • 原列表 [10, 50, 60, 12, 98.5, 30]
  • 默认升序排序后 [10, 12, 30, 50, 60, 98.5]
  • 调用参数升序排序后 [10, 12, 30, 50, 60, 98.5]
  • 调用参数降序排序后 [98.5, 60, 50, 30, 12, 10]

看上面代码,sort()括号内没有填写参数的时候默认就是升序排序,跟调用参数reverse=False是一样的效果,这些都是在原列表基础上修改的排序,不会改变列表的标识ID

sorted()

内置函数,默认是升序排序,可以调用参数进行降序排序

lst = [10, 50, 60, 12, 98.5, 30]
print('原列表', lst)
lst1 = sorted(lst)
print('默认升序排序后', lst1)
lst1 = sorted(lst, reverse=False)
print('调用参数升序排序后', lst1)
lst1 = sorted(lst, reverse=True)
print('调用参数降序排序后', lst1)

运行结果:

  • 原列表 [10, 50, 60, 12, 98.5, 30]
  • 默认升序排序后 [10, 12, 30, 50, 60, 98.5]
  • 调用参数升序排序后 [10, 12, 30, 50, 60, 98.5]
  • 调用参数降序排序后 [98.5, 60, 50, 30, 12, 10]

与上面sort()的结果一致,不同的是sorted()内置函数需要修改后赋值给新的变量,也就是会产生新的列表对象,括号内,可以填写两个参数,用分隔符逗号,隔开,第一个参数为要修改排序的原列表变量名,第二个参数为升序或者降序的调用参数,不填写默认为升序排序

lst = [10, 50, 60, 12, 98.5, 30]
print('原列表', lst)
print('默认升序排序后', sorted(lst))

运行结果:

  • 原列表 [10, 50, 60, 12, 98.5, 30]
  • 默认升序排序后 [10, 12, 30, 50, 60, 98.5]

也可以像上列代码一样,无需赋值给新的变量,直接调用内置函数sorted()修改原列表后输出

总结:列表内元素整数和浮点数可以进行排序,不能和字符串进行混合排序,字符串只能和字符串进行排序

列表生成式

[ 代表列表元素的表达式 for 自定义变量 in 可迭代对象 ]

lst = [i for i in range(1, 10)]
print(lst)

运行结果:

  • [1, 2, 3, 4, 5, 6, 7, 8, 9]
a = 1
lst = [a for i in range(1, 10)]
print(lst)

运行结果:

  • [1, 1, 1, 1, 1, 1, 1, 1, 1]
lst = [i * i for i in range(1, 10)]
print(lst)

运行结果:

  • [1, 4, 9, 16, 25, 36, 49, 64, 81]

看上面代码,第一段代表列表元素的表达式直接用的生成式中的自定义变量i,后面的可迭代对象有多少可遍历对象,for...in...循环就循环运行多少次,每一次运行后赋值到自定义变量i,因为前面我们代表列表元素的表达式用的是自定义变量i,所以每次运行后获取的列表元素是for...in...循环赋予自定义变量i的值,这个列表元素不会随着循环删除,而是一次次按顺序保存起来,for...in...循环结束运行后,就生成了一个列表。第二段代码中,代表列表元素的表达式使用的是另外一个不相关的自定义变量a,变量a的值一直是整数1for...in...循环每次运行后,获取的列表元素都是整数1,最后生成了列表[1, 1, 1, 1, 1, 1, 1, 1, 1]。第三段代码中,代表列表元素的表达式使用的是带乘法运算符的表达式,两个参数都是自定义变量i,所以每次for...in...循环遍历赋值后,代表列表元素的表达式都要进行一次运算后才能获取列表元素,例如变量i的值为11 * 1 = 1,变量i的值为22 * 2 = 4,变量i的值为33 * 3 = 9,最后生成了列表[1, 4, 9, 16, 25, 36, 49, 64, 81]

总结:

代表列表元素的表达式,可以是整数,浮点数,变量,字符串等等,几乎任何对象都可以,它只用于每次运行之后获取列表元素,后面的for...in...循环只是用来决定生成式的运行次数,生成列表有多少个元素就看它运行多少次,最后面的可迭代对象不一定要是range()函数,也可以是字符串,列表,等等的可迭代对象,自行尝试

最后再来看一种生成方法

lst = list(range(1, 10))
print(lst)

运行结果:

  • [1, 2, 3, 4, 5, 6, 7, 8, 9]

直接用内置函数list()把可迭代对象转换成列表,效果和上面生成式一样

最后修改:2021 年 10 月 19 日 09 : 06 PM