Python全栈之路----数据类型—列表

1.列表是一个数据的集合，集合内可以放任何数据类型，可对集合进行方便的增删改查操作。列表里面的数可以重复。

L1 = [ ] #定义空列表
L2 = [ 'a' , 'b' , 'c' , 'd' ] #存四个值，索引为0-3
L3 = [ 'abc' , [ 'def' , 'ghi' ] ] #嵌套列表

2.列表的功能：

创建，查询，插入，删除，移动，修改，排序

L[n]  L.count(n)  L.index(n)  L.append(n)  L.insert(m,n)  del L[n]  L.remove(n)  L.pop()  L.sort()正序   L.reserve()

 >>> L2 = ['a','b','c','d','e',1,2] #创建一个列表
 >>> L2[2] #通过索引取值
   'c'
  >>> L2[-1] #通过索引从裂变右边开始取值
   2
  >>> L2.index('a') #返回指定元素索引值，从左向右查找，找到第一个匹配的字符的位置
   0
  >>> L3 = [1,1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,3,3,4,4,4,5,5,8,8,8,8,8,8]
  >>> L3[2] #通过索引值取值
  1
  >>> L3.count(3) #查找有多少个字符为3的索引
  7
  >>> n = L3.index(2)
  >>> L3[n] #n是L3种2的索引值，L3[n]是索引值为n的元素
  2
  >>> L3[L3.index(2)]
  2
  >>> L3[0:3] #列表切片，顾头不顾尾
  [1, 1, 1]
  >>> L3[-5:-1] #后面的列表切片，顾头不顾尾
  [8, 8, 8, 8]
  >>> L3[-5:] #-5位置的字符及其后面的所有字符
  [8, 8, 8, 8, 8]
  >>> L3[:3]
  [1, 1, 1]
  >>> L3[:] #和L3输出结果一致
  [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8]
  >>> L3[:7:2] #0-6切片，先取L3[0]，然后每两个取一个
  [1, 1, 1, 2]
  >>> L3[:9:3] #3叫做步长
  [1, 1, 2]
  >>> L3.append('Alex') #在列表最后面追加字符
  >>> L3
  [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8, 'Alex']
  >>> L3.insert(0,'Jane') #在列表索引值为0的位置插入数据Jane
  >>> L3
  ['Jane', 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8, 'Alex']
  >>> L3[3] = 'Mary' #把索引值为3的位置的元素替换成Mary
  >>> L3
  ['Jane', 1, 1, 'Mary', 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8, 'Alex']
  >>> L3[4:6] = 'PeiQi' #批量修改，由于位置不够，PeiQi被拆分，后面的元素后移
 >>> L3
  ['Jane', 1, 1, 'Mary', 'P', 'e', 'i', 'Q', 'i', 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8, 'Alex']
  >>> L3.pop() #删除最后一个元素，返回最后一个元素的值
  'Alex'
  >>> L3.remove(4) #删除从左边数第一个为4的元素
  >>> L3
  ['Jane', 1, 1, 'Mary', 'P', 'e', 'i', 'Q', 'i', 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8]
  >>> del L3[3] #全局性指令，删除索引值为3的元素
  >>> L3
  ['Jane', 1, 1, 'P', 'e', 'i', 'Q', 'i', 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8]
  >>> del L3[8:16] #批量删除，顾头不顾尾
  >>> L3
  ['Jane', 1, 1, 'P', 'e', 'i', 'Q', 'i', 3, 3, 3, 3, 3, 4, 4, 5, 5, 8, 8, 8, 8, 8, 8]

（3）列表是有序的，但int和str类型不能一起排序。str按照ASCII排序，sort是排序，reverse是顺序反过来，extend是扩展，clear是把整个列表清空，copy是拷贝。

copy：  查看内存地址  id(i)  变量有地址，列表本身有一个地址，列表中的每一个元素又都有自己单独的地址

如果 a = 1   a = b  ，b指向的是1，不是a，b不随着a的变化而变化；

如果L1 = L ，L1指向L的内存地址，将L的内存地址比作一个装了很多水果的果盘，那么L1也指的是这个果盘，那么L变化实际是果盘变化，所以L1随L的变化而变化，同时L也会随L1的变化而变化；

如果L1 = L.copy()，将L的内存地址比作一个装了很多水果的果盘，那么L1指的是将这个果盘复制的一个新果盘，但是果盘里的水果并没有被复制，水果是两个果盘共享，所以L变化是旧果盘变化，新果盘不变，所以L1不随L的变化而变化；

>>> L = ['a','d','b','r','A']
>>> L.sort() #将L排序
>>> L
['A', 'a', 'b', 'd', 'r']>>> L.insert(2,'*')
>>> L.insert(3,'#')
>>> L
['A', 'a', '*', '#', 'b', 'd', 'r']
>>> L.sort() #按照ASCI码排序
>>> L
['#', '*', 'A', 'a', 'b', 'd', 'r']
>>> L.reverse() #把顺序反过来
>>> L
['r', 'd', 'b', 'a', 'A', '*', '#']
>>> L4 = [1,2,3,4]
>>> L + L4 #L和L4拼接在一起
['r', 'd', 'b', 'a', 'A', '*', '#', 1, 2, 3, 4]
>>> L.extend(L4) #把L4扩展到L里面
>>> L
['r', 'd', 'b', 'a', 'A', '*', '#', 1, 2, 3, 4]
>>> L.clear() #清空
>>> L
[]
>>> L = [1,2,4,5]
>>> L.copy()
[1, 2, 4, 5]
>>> L1 = L.copy()
>>> L1
[1, 2, 4, 5]
>>> L=[3,4,5]
>>> L1
[1, 2, 4, 5]
>>> L1 = L
>>> L[2] = 'Alex'
>>> L
[3,4, 'Alex']
>>> L1
[3,4, 'Alex']

（4）深浅copy

①浅copy：n3 = names   两个列表中的小列表元素改变同步，其余元素独立改变

>>> names = ['alex','jack','jane',['LT','']]
>>> n3 = names.copy()
>>> names
['alex', 'jack', 'jane', ['LT', '']]
>>> n3
['alex', 'jack', 'jane', ['LT', '']]
>>> names[0] = 'Alex'
>>> names
['Alex', 'jack', 'jane', ['LT', '']]
>>> n3
['alex', 'jack', 'jane', ['LT', '']]
>>> n3[2] = 'Jane'
>>> n3
['alex', 'jack', 'Jane', ['LT', '']]
>>> names
['Alex', 'jack', 'jane', ['LT', '']]
>>> n3[3][1] = 20
>>> n3
['alex', 'jack', 'Jane', ['LT', 20]]
>>> names
['Alex', 'jack', 'jane', ['LT', 20]]

②深copy：将列表完全复制，两个列表完全独立

>>> import copy
>>> n = copy.deepcopy(names)
>>> n
['Alex', 'jack', 'jane', ['LT', 20]]
>>> n[3][0] = 'LongTing'
>>> n
['Alex', 'jack', 'jane', ['LongTing', 20]]
>>> names
['Alex', 'jack', 'jane', ['LT', 20]]