Python数据结构之list

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]]

最后总结下:

在非嵌套的数据结构中,不存在深浅复制的问题.

而在对嵌套了可变结构的数据进行复制时,务必要使用深复制.