List的特性是有序,可迭代,可变.
List运算符及成员运算
表达式 | 结果 | 描述 |
[1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
3 in [1, 2, 3] | TRUE | 元素是否存在于列表中 |
List的常用方法
序号 | 方法 | 说明 |
1 | list.append(obj) | 在列表末尾添加新的对象 |
2 | list.count(obj) | 统计某个元素在列表中出现的次数 |
3 | list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
4 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
5 | list.insert(index, obj) | 将对象插入列表的指定引索位置 |
6 | list.pop(obj=list[-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值.也可指定引索值 |
7 | list.remove(obj) | 移除列表中某个值的第一个匹配项 |
8 | list.reverse() | 反向排列列表中元素 |
9 | list.sort([func]) | 对原列表进行排序 |
10 | list.copy() | 浅复制列表 |
11 | list.clear() | 清空列表 |
List的补充知识点
- 索引越界
对于空列表来说,指定实际的索引会引发越界的错误,而使用 [ : ]或者[ :-1]则可以有效的避免.
L=[]
print(L[0])
#输出:
Traceback (most recent call last):
File "D:/Pycharm/xxx.py", line 2, in <module>
print(L[0])
IndexError: list index out of range
print(L[:])
print(L[ :-1])
#输出:
[]
[]- 切片的技巧
切片实际调用的是内置的slice函数.
L=[1,2,3,4,5,6,7,8,9,10]
print(L[: : 2])#正序间隔一个再取一个
print(L[: :-1])#倒序,类似reverse函数
print(L[: :-2])#倒序后间隔一个再取一个
#输出:
[1, 3, 5, 7, 9]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[10, 8, 6, 4, 2]- 深浅复制
在pyhton中'=='和关键字is都可以用于判断对象相等情况,但这两种是有很大的区别的:
'=='用于判断对象的值是否相等.
is关键字是判断对象在内存中的id是否相等.
用具体的例子来说明下:
#方式一:
L1=[1,2,3]
L2=L1
#方式二:
K1=[1,2]
K2=[1,2]
L1==L2 #输出True
L1 is L2 #输出True
K1==K2 #输出True
K1 is K2 #输出False在这两个不同方式的赋值中,在内存中到底是怎么表示的呢? 下面用图了说明:
在方式一中,L2其实指向L1,再统一指向同一个内存对象,所以内存ID相同,而且值也相同.
而方式二中,K1,K2虽然值相同,但却是指向的不同的内存对象,故内存ID不同.
再来聊聊可变对象和不可变对象,我们知道str是不可变对象,list是可变对象,这个可变不可变具体是什么意思呢?
实际上真正决定可变不可变的就是实实在在的内存对象.
还是以代码来说明:
s='abc'
k=[1,2,3]
print(s.upper())#输出:ABC. 有返回值,说明返回了新的对象,而原内存对象未改变
print(k.append(100))#输出:None. 无返回值,是在原内存对象进行了修改
print(s)#输出:abc
print(k)#输出[1,2,3,100]了解以上两点后,就可以讨论深浅复制的问题了.
首先来看个例子:
#例一
L=[1,2,3]
K=L.copy() #或者 K=L[:]
L.append(100)
print(L)#输出:[1, 2, 3, 100]
print(K)#输出:[1, 2, 3]
#例二
L1=[1,2,[3]]
K1=L1.copy()
L1[-1].append(100)
print(L1)#输出:[1, 2, [3, 100]]
print(K1)#输出:[1, 2, [3, 100]]在例一中,变量对应的都是非嵌套结构,而在例二中,变量对应的是嵌套结构(不限于列表嵌套列表).
而在对变量做类似的操作后,输出的结果却不同.
首先可以判断的是,在非嵌套的结构中,是不存在深浅复制的问题的.
而若在嵌套可变对象的数据结构中,对变量进行的复制仅仅是浅复制.
可变对象(实际是内存对象)的值被修改后,该内存对象并没有改变(既id没有改变).复制的本质是记录每个元素的内存对象或者或每个元素的内存id,从原变量复制产生的新变量是按照记录的内存对象(id值)去查找和显示对应的元素,虽然原变量的元素值已经改变,但该元素的内存对象并没有改变,所以新变量的会随着原变量的改变而改变.
若要避免这样的情况,就需要使用深复制.python的内置模块copy提供了该功能.
还是以同样的代码举例:
import copy
L1=[1,2,[3]]
K1=copy.deepcopy(L1)
L1[-1].append(100)
print(L1) #输出:[1, 2, [3, 100]]
print(K1) #输出:[1, 2, [3]]最后总结下:
在非嵌套的数据结构中,不存在深浅复制的问题.
而在对嵌套了可变结构的数据进行复制时,务必要使用深复制.
