列表元素的增加和删除
其实是数值的拷贝
当列表增加和删除元素时,列表会自动进行内存管理,大大减少了程序员的负担。但这个特点涉及列表元素的大量移动,效率较低。除非必要,我们一般只在列表的尾部添加元素或删除元素,这会大大提高列表的操作效率。
apend方法:
原地修改列表对象,是真正的列表尾部添加新的元素,速度最快,推荐使用。
>>>a=[20,40]
>>>a.append(80)
>>>a
[20,40,80]
+运算符操作: 并不是真正在尾部添加元素,而是创建新的列表对象。
并不是真正的尾部添加元素,而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样,会涉及大量的复制操作,对于操作大量元素不建议使用。
>>>id(a)46016072
>>>a=a+[50]
>>>id(a)
46015432
通过如上测试,我们发现变量a的地址发生了变化。也就是创建了新的列表对象。
extend()方法:将目标列表的所有元素添加到本列表的尾部,属于原地操作,不创建新的列表对象。
>>>a=[20,40]
>>>id(a)
46016072
>>>a.extend([50,60])
>>>id(a)
46016072
Insert()插入元素
使用insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动,会影响处理速度。涉及大量元素时,尽量避免使用。类似发生这种移动的函数还有:remove()、pop()、del(),它们在删除非尾部元素时也会发生操作位置后面元素的移动。
>>>a=[10,20,30]
>>>a.insert(2,100)
>>>a
[10,20,100,30]
乘法扩展
使用乘法扩展列表,生成一个新列表,新列表元素时原列表元素的多次重复
>>>a=[sxt,100]
>>>b=a*3
>>>a
['sxt',100]
>>>b
['sxt',100,'sxt',100,'sxt',100]
适用于乘法操作的,还有:字符串、元组。例如:
>>>c='sxt'
列表元素的删除
del 删除 (本质也是元素的拷贝)
删除列表指定位置的元素。
>>>a=[10,20,30]
>>>del af[1]
>>>a
[10,30]
pop()方法
pop()删除并返回指定位置元素,如果未指定位置默认操作列表最后一个元素。
>>>a=[10,20,30,40,50]
>>>b=a.pop()
50
>>>a
[10,20,30,40]
>>>a.pop(1)
20
>>>a
[10,30,40]
remove()方法
与del和pop针对偏移量不同,remove直接针对元素。
删除首次出现的指定元素,若不存在该元素抛出异常
>>>a=[10,20,30,40,50,20,30,20,30]
>>>a. remove(20)
>>>a
[10,30,40,50,20,30,20,30]
>>>a. remove(100)
Traceback(most recent call last): File"<pyshell#208>", line 1, in <module>
a. remove(100)
ValueError: list. remove(x):x not in list
列表元素访问和计数
通过索引直接访问元素
我们可以通过索引直接访问元素。索引的区间在[0,列表长度-1]这个范围。超过这个范围则会抛出异常。
>>>a=[10,20,30,40,50,20,30,20,30]
>>>a[2]
30
>>>a[10]
Traceback(most recent call last):File"<pyshell#211>",line 1,in <module>
a[10]
IndexEror:list index out of range
index()获得指定元素在列表中首次出现的索引
index0可以获取指定元素首次出现的索引位置。语法是:index(value,[start.[end]).其中,start和end 指定了搜索的范围。
>>>a=[10,20,30,40,50,20,30,20,30]
>>>a.index(20)
1
>>>a.index(20,3)#从索引位置3开始往后搜索的第一个20
5
>>>a.index(30,5,7)#从索引位置5到7这个区间,第一次出现30元素的位置
count()获得指定元素在列表中出现的次数
count()可以返回指定元素在列表中出现的次数。
>>>a=[10,20,30,40,50,20,30,20,30]
>>a.count(20)
3
len()返回列表长度
Len()返回列表长度,即列表中包含元素的个数。
>>>a=[10,20,30]
>>>len(a)
3
成员资格判断
判断列表中是否存在指定的元素,我们可以使用count()方法,返回0则表示不存在,返回大于0则表示存在。一般我们会使用更加简洁的in关键字来判断,直接返回True或False。
>>>a=[10,20,30,40,50,20,30,20,30]
>>>20 in a
True
>>>100 not in a
True
列表切片操作
列表、元组、字符串切片操作大同小异
(包头不包尾？？)
切片是Python序列及其重要的操作,适用于列表、元组、字符串等等。切片的格式如下:
切片slice操作可以让我们快速提取子列表或修改。标准格式为:[起始偏移量 start终止偏移量end[:步长stepl]
当步长省略时顺便可以省略第二个冒号
切片操作时,起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围,也不会报错。起始偏移量小于0则会当做0,终止偏移量大于“长度-1”会被当成”长度-1”。例如:
>>>[10,20,30,40][1:30]
[20,30,40]
我们发现正常输出了结果,没有报错。
列表的遍历
for obj in listObj:
print(obj)
列表的排序
修改原列表,不建新列表的排序
46017416
>>>a.sort0#默认是升序排列
>>>a
[10,20,30,40]
>>>a=[10,20,30,40]
>>>a.sort(reverse=True)#降序排列
>>>a
[40,30,20,10]
>>>import random
>>>random.shuffle(a)#打乱顺序
>>>a
[20,40,30,10]
建新列表的排序
通过内置函数sorted()进行降序排列,这个方法返回新列表,不对原列表做修改。
>>>a=[20,10,30,40]
>>>id(a)
45840584
>>>b=sorted(a)
>>>b
[10,20,30,40]
>>>id(a)
45840584
>>>id(b)
I
46016072
>>>c=sorted(a,reverse=True)#降序
>>>c
[40,30,20,10]
生成的列表b和c是完全新的对象
reversed()返回迭代器
内置函数reversed()也支持进行逆序排列,与列表对象reverse()方法不同的是,内置函数reversed()不对原列表做任何修改,只是返回一个逆序排列的迭代器对象。
>>>a=[20,10,30,40]
>>>c=reversed(a)
>>>c
<list_reverseiterator object at 0x0000000002BCCEB8>
>>>list(c)
[40,30,10,20]
>>>list(c)
[]
我们打印输出c发现提示是:list reverseiterator。也就是一个迭代对象。同时,我们使用list(c)进行输出,发现只能使用一次。第一次输出了元素,第二次为空。那是因为迭代对象在第一次时已经遍历结束了,第二次不能再使用。
注:关于迭代对象的使用,后续章节会进行详细讲解。
列表相关的
max
min
sum
[40,30,20,10]
>>>a=[3,10,20,15,9]
>>>max(a)
20
>>>min(a)
3
对数值型列表的所有元素进行求和操作,对非数值型列表运算则会报错。
>>>a=[3,10,20,15,9]
>>>sum(a)
57
多维列表(列表套列表)
二维列表
一维列表可以帮助我们存储一维、线性数据。
二维列表可以帮助存储二维、表格的数据。
源码:a=[[“高小一,18,30000,“北京"],[“高小二”,19,20000,"上海],[“高小一,20,10000,"深圳”]]
a=[
[“高小一,18,30000,“北京],
[“高小二,19,20000,"上海],
[“高小五,20,10000,"深圳]
]
for m in range(3):
for n in range(4)
print(a[m][n].end="\t")
Print() #打印完一行,换行
嵌套循环打印二维列表的所有数据
a=[]
for m in range(3):
for n in range(4):
print(a[m][n],end="\t")
print()
元组tuple
43 列表属于可变序列,元组属于不可变序列
列表属于可变序列,可以任意修改列表中的元素。元组属于不可变序列,不能修改元组中的元素。因此,元组没有增加元素、修改元素、删除元素相关的方法。
因此,我们只需要学习元组的创建和删除,元组中元素的访问和计数即可。元组支持如下操作:
1.索引访问2.切片操作3.连接操作
4.成员关系操作5.比较运算操作
6.计数:元组长度len0、最大值max0、最小值min0、求和sum0等。
元组的创建
- 通过()创建元组,小括号可以省略,如果元组只有一个元素,必须后面加逗号
>>>a=(1)
>>>type(a)
<class'int'>
>>>a=(1,)#或者a=1,
>>>type(a)
<class tuple'>
2. 通过tuple()创建元组
tuple(可迭代的对象)
b=tuple() #创建一个空元组对象
b=tuple("abc")
b=tuple(range(3))
b=tuple([2,3,4])
总结:
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。
元组的元素访问和计数
1.元组的元素不能修改
>>>a=(20,10,30,9,8)
>>>a[3]=33
Traceback(most recent call last): File "<pyshell#313>,line 1,in <module>
a[3]=33
TypeError:tuple'object does not support item assignment
2.元组的元素访问和列表一样,只不过返回的仍然是元组
>>>a=(20,10,30,9,8)
>>>a[1]
10
>>>a[1:3]
(10,30)>>>a[4]
(20,10,30,9)
- 列表关于排序的方法list.sorted()修改原列表对象,只能使用内置函数sorted(tupleObj),生成新的列表对象
>>>a=(20,10,30,9,8)
>>>sorted(a)
[8,9,10,20,30]
zip
zip(列表1,列表2)将多个列表对应位置的元素组成元组,并返回zip对象。
>>>a=[10,20,30]
>>>b=[40,50,60]
>>>c=[70,80,90]
>>>d=zip(a,b,c)
>>>list(d)
[(10,40,70),(20,50,80),(30,60,90)]
生成器的使用测试
从形式上看,生成器推导式与列表推导式类似,只是生成器推导式使用小括号。列表推导式直接生成列表对象,生成器推导式生成的不是列表也不是元组,而是一个生成器对象。我们可以通过生成器对象,转化成列表或者元组。也可以使用生成器对象的_next_0方法进行遍历,或者直接作为迭代器对象来使用。不管什么方式使用,元素访问结束后,如果需要重新访问其中的元素,必须重新创建该生成器对象。
两个下划线:__next__()
>>>s=(x*2 for x in range(5))
>>>s
<generator object<genexpr> at 0x0000000002BDEB48>
>>>tuple(s)(0,2,4,6,8)
>>>list(s)#只能访问一次元素。第二次就为空了。需要再生成一次
[]
>>>s
<generator object<genexpr> at 0x0000000002BDEB48>
>>>tuple(s)
>>s =(x*2 for x in range(5))
>>>s.__next__00
>>>s.__next__02
>>>s.__next__0
元组总结
元组的核心特点:不可变序列
元组的访问和处理速度比列表快
与整数和字符串一样,元组可以作为字典的键,列表永远不能作为字典的键使用。
368
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
