列表 LIST

Posted 2022-01-26 qianslup

列表  LIST

定义：

由一系列按特定顺序排列的元素组成的有序集合。

 

创建：

1.list_1 = []        方括号[] 来表示列表，并用逗号来分隔其中的元素

2.list_1 = list()   小括号()中的元素必须可以迭代。 

list_1 = [1,2,3]                #结果：[1, 2, 3]
list_2 = [‘123‘]                #结果：[‘123‘]            
list_3 = list(range(6))         #结果：[0, 1, 2, 3, 4, 5]
list_4 = list(‘123‘)            #结果:[‘1‘, ‘2‘, ‘3‘]
list_5 = list(‘hello‘)          #结果:[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘]
list_6 = list(1)                #结果:‘int‘ object is not iterable
list_7 = list(1,2)              #结果：list expected at most 1 arguments, got 2
list_8 = list((1))              #结果:‘int‘ object is not iterable
list_9 = list((1,2))            #结果：[1, 2]
list_10 = list[1,‘2‘]           #结果：‘type‘ object is not subscriptable
list_10 = [1,‘2‘]               #结果：[1, ‘2‘]

 

 

 

 

切片：

list_p = list(‘hello python‘)   #结果:[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘ ‘, ‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
#list_p[x:y]从0开始，左闭右开;x可以省略，默认为0，y可以省略，默认为-1
list_p[:4]                     #结果：[‘h‘, ‘e‘, ‘l‘, ‘l‘]
list_p[:]                      #结果:[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘ ‘, ‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
#list_p[x:y:z]，z不为负数
list_p[0:-1:2]                 #结果:[‘h‘, ‘l‘, ‘o‘, ‘p‘, ‘t‘, ‘o‘]
#倒序排列
print(list_p[::-1])            #结果:[‘n‘, ‘o‘, ‘h‘, ‘t‘, ‘y‘, ‘p‘, ‘ ‘, ‘o‘, ‘l‘, ‘l‘, ‘e‘, ‘h‘]
print(list_p[::-2])            #结果:[‘n‘, ‘h‘, ‘y‘, ‘ ‘, ‘l‘, ‘e‘]

 

 

索引：

list_p = list(‘hello python‘) 
#要么是整数：
list_p[4]                #结果：[‘0‘]
#要么是切片：
list_p[:4]               #结果：[‘h‘, ‘e‘, ‘l‘, ‘l‘]

 

增：

一次只能增加一个元素

list_i = list(‘hello‘)
#append: 在最后未知增加元素
list_i.append(‘a‘)          #结果：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘a‘]  
#在任意未知增加元素,注意不是最后未知
list_i.insert(-1,‘c‘)      #结果：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘c‘, ‘a‘] 
#原来元素后移
list_i.insert(1,‘b‘)    #结果：[‘h‘, ‘b‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘a‘, ‘a‘] 
list_i

批量增加一个元素

list_i = list(‘hello‘)
list_p = list(‘python‘)
list_i.extend(list_p)               #结果：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
list_i + list_p                     #结果：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘, ‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]  

注意：extend执行速度更快。

复制列表中的元素

list_i = list(‘he‘)
list_i * 3
#结果：[‘h‘, ‘e‘, ‘h‘, ‘e‘, ‘h‘, ‘e‘]

 

 

删：

通过索引删除

不可以在删除时赋值给变量，若无提前赋值，一旦删除，无法使用。

list_i = list(‘hello‘)
char = list_i[-1]
del list_i[-1]         
print(char)            #输出：o
print(list_i)          #输出：[‘h‘, ‘e‘, ‘l‘, ‘l‘]

可以在删除时赋值给给变量，删除之后还能使用。若pop()中未输入参数，则默认为最后一位

list_i = list(‘hello‘)
del list_i[2]         #输出：[‘h‘, ‘e‘, ‘l‘, ‘o‘]
cha = list_i.pop(2)   #输出：‘l‘

通过元素删除

无需知道索引，如果有多个相同元素，删除的是第一次出现的元素。删除的元素提前赋值则可以继续使用。

list_i = list(‘SOS‘)
char = ‘S‘
list_i.remove(char)
print(char)            #输出：S
print(list_i)          #输出：[‘O‘, ‘S‘]

 

改：

列表名[索引] = 新值

 

查：

print（列表名[索引] ）

 

列表表达式：

 [表达式 for 变量 in 列表 if 条件]

或者   [表达式 for 变量 in 列表 ]

List_e = [ x ** 2 for x in range(10) ]
List_e 
#结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
List_f = []
for x in range(10):
    List_f.append( x ** 2 )    
List_f
#结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
List_g = list(map(lambda x:x ** 2,range(10)))
List_g
#结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

 

方法：

 

函数：

序号	函数	描述
1	len(list)	统计list中有多少个元素
2	max(list)	返回list中的最大值
3	min(list)	返回list中的最小值
4	list(seq)	将其他序列转化为列表
5	sorted(list)	将list中的元素进行排序

 

 

 

 

 

 

 

 

排序：

临时排序

排序之后原列表不变

list_n = [2,7,5,8,1]
print(sorted(list_n))                    #输出：[1, 2, 5, 7, 8]
print(sorted(list_n,reverse = True))     #输出：[8, 7, 5, 2, 1]
print(list_n)                            #输出：[2, 7, 5, 8, 1]
list_c = [‘a‘,‘abc‘,‘ab‘,‘acb‘,‘cb‘]
print(sorted(list_c,key = len))         #输出：[‘a‘, ‘ab‘, ‘cb‘, ‘abc‘, ‘acb‘]

 

永久排序

排序之后列表顺序发生改变

list_n = [2,7,5,8,1]
list_n.sort()
print(list_n)                         #输出：[1, 2, 5, 7, 8]
list_n.sort(reverse = True)
print(list_n)                         #输出：[8, 7, 5, 2, 1]
list_c = [‘a‘,‘abc‘,‘ab‘]
list_c.sort(key = len)
print(list_c)                         #输出：[‘a‘, ‘ab‘, ‘abc‘]

 

复制列表：

参考：https://blog.csdn.net/u011630575/article/details/78604226

—–深复制，即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。 使用切片或者deepcopy()

—–而等于赋值，并不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变。 list_1 = list_2

—–而浅复制要分两种情况进行讨论： 

1）当浅复制的值是不可变对象（数值，字符串，元组）时和“等于赋值”的情况一样，对象的id值与浅复制原来的值相同。

2）当浅复制的值是可变对象（列表和元组）时会产生一个“不是那么独立的对象”存在。有两种情况：

第一种情况：复制的 对象中无 复杂 子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。

第二种情况：复制的对象中有 复杂 子对象 （例如列表中的一个子元素是一个列表），如果不改变其中复杂子对象，浅复制的值改变并不会影响原来的值。 但是改变原来的值 中的复杂子对象的值  会影响浅复制的值。

对于简单的 object，例如不可变对象（数值，字符串，元组），用 shallow copy 和 deep copy 没区别

复杂的 object， 如 list 中套着 list 的情况，shallow copy 中的 子list，并未从原 object 真的「独立」出来。也就是说，如果你改变原 object 的子 list 中的一个元素，你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。

 

改变复制后的表，原表不变

list_n = [2,7,5,8,1,‘a‘]
list_m = list_n[:]
list_m.insert(-1,‘b‘)
print(list_n)                #输出：[2, 7, 5, 8, 1, ‘a‘]
print(list_m)                #输出：[2, 7, 5, 8, 1, ‘b‘, ‘a‘]
list_v = list_n.copy()
list_v.insert(-1,‘b‘)
print(list_n)                #输出：[2, 7, 5, 8, 1, ‘a‘]
print(list_v)                #输出：[2, 7, 5, 8, 1, ‘b‘, ‘a‘]

改变复制后的表，原表随之改变。

list_21 = [‘h‘, ‘e‘, ‘l‘, ‘l‘,  ‘o‘,[1,2]]
list_22 = list_21
list_21.insert(-1,‘b‘)
print(list_21)                #输出：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘b‘, ‘o‘]
print(list_22)                #输出：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘b‘, ‘o‘]
list_23 = list_21.copy()
list_21[-1][-1] = 10
print(list_21)                #输出：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘b‘, [1, 10]]
print(list_23)                #输出：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘b‘, [1, 10]]
#如果改变的是一个简单子对象，则仍相对独立
list_21.insert(-1,‘d‘)
print(list_21)                #输出：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘b‘, ‘d‘, [1, 10]]
print(list_23)               #输出：[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘b‘, [1, 10]]

 

遍历列表