列表增加、查找、删除、修改

1. 列表元素的增加

append是函数；member.append()是方法——属于对象的函数称为方法
.append()：参数是一个插入列表的元素，参数作为一个元素追加到列表的末尾
.extend()：参数是一个列表是使用一个列表来扩张另一个列表，参数作为一个列表追加列表的末尾。——列表拼接用extend，不要用+
两者都是添加到末尾，只有一个参数
.insert(插入的位置的索引值，插入的元素)——列表索引值从0开始

>>> member = [1996,424,644]
>>> member.append("梁")              #.append()
>>> member
[1996, 424, 644, '梁']
​
member.extend(["吴","love"])         #.extend()
>>> member
[1996, 424, 644, '梁', '吴', 'love']　　　
​
>>> member.insert(1,307)             #.insert()
>>> member
[1996, 307, 424, 644, '梁', '吴', 'love']

2. 列表元素的查找

>>> member[0]
1996

代码打印成双列的样式

>>> member = ['一',1,'二',2,'三',3]
>>> member
['一', 1, '二', 2, '三', 3]
>>> for i in member:
    print(i)
​
    
一
1
二
2
三
3

第一种方法：

>>> count = 0
>>> length = len(member)
>>> while count < length:
    print(member[count],member[count+1])
    count +=2
一 1
二 2
三 3

第二种方法：

>>> length = len(member)
>>> for i in range(length):
    if i%2 == 0:                #i对2取余等于0，有0，2，4；而1，3不满足条件
        print(member[i],member[i+1])
        i +=1       
一 1
二 2
三 3

3. 列表元素的删除

（1）.remove( ) ：方法 可以删除指定元素名的列表元素，它的参数是要删除元素的元素名

>>> member.remove('love')
>>> member
[307, 1996, 424, 644, '梁', '吴']
>>> 

（2）del：不是函数，也不是方法，是一条语句
del member会把整个列表删掉
del也可以通过切片来批量删除多个列表元素：

>>> del member[2]
>>> member
[307, 1996, 644, '梁', '吴']

（3）.pop( )：从列表中选取最后一个元素，并且有返回值
.pop() 是唯一一个有返回值的列表元素删除方法
可以添加一个参数，填索引值

>>> member.pop()
'吴'
>>> member
[307, 1996, 644, '梁']
#输入索引参数，赋值
>>> name = member.pop(2)
>>> name
644
>>> member
[307, 1996, '梁']

（4）.clear( ) ：方法用来清空整个列表，最终得到一个空列表

>>> member.clear()
>>> member
[]

4. 列表元素的修改

>>> member = [1996,424,644,'梁', '吴', 'love']
#通过索引值直接修改
>>> member[2] = 980
>>> member
[1996, 424, 980, '梁', '吴', 'love']
​
#将0和1位置上的元素调换
>>> x = member[0]
>>> member[0] = member[1]
>>> member[1] = x
>>> member
[307, 1996, 424, 644, '梁', '吴', 'love']
​

通过列表的切片方法进行批量修改
切片获取的内容空间是连续的时候，修改时内容可以多可以少；切片获取的内容空间是不连续的时候，修改时内容必须一一对应：

>>> member = [1996,424,644,'梁', '吴', 'love'] 
>>> member[2:5] = 2,3,4          #切片空间连续
>>> member
[1996, 424, 2, 3, 4, 'love']   
​

>>> member[0:4:2] = 1,6          #[ start : stop : 步长]
>>> member                       #切片空间不连续，要一一对应 
[1, 424, 6, '梁', '吴', 'love']
​

>>> member = [1996,424,644,'梁', '吴', 'love']        #列表的拷贝
>>> member[:]
[1996, 424, 644, '梁', '吴', 'love']

member[ : 5：１ ]——开始索引位置为0，结束位置为5，步长为１
member[ : 5：－１ ]——如果我们把步长设置成 -1，可以实现从右向左查找，开始位置为－１
member[ 2 : ]——开始索引位置为2，结束位置为列表末尾，默认步长为１
member[ : ]——列表的拷贝

5. 列表常用操作符

（1）比较操作符

>>> list1 = [123,456]
>>> list2 = [345,133]
>>> list1 < list2
True

（2）逻辑操作符

>>> list3 = [33,521]
>>> ( list1 < list2) and (list2 > list3)
True
>>> ( list1 < list2) and (list2 == list3)
False
>>> ( list1 > list2) or (list2 == list3)
False

（3）连接操作符

>>> list4 = list1 + list2   
>>> list4
[123, 456, 345, 133]
#加法连接有时候是违规的，不能用来添加一个新元素，会报错———因为加法两侧类型需要一致
>>> list4 + "love"
​
TypeError: can only concatenate list (not "str") to list

（4）重复操作符——*

>>> list1 *3
[123, 456, 123, 456, 123, 456]
>>> list1 *= 3         #将list1乘以3
>>> list1
[123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456]

（5）成员操作符——只能影响一个层次的成员关系{与break和continue只影响一个循环类似}

>>> list5 = [123,['love','like'],456]
>>> 123 in list5
True
>>> 123 not in list5
False

判断列表中的列表中的值

>>> 'love' in list5
False
>>> 'love' in list5[1]
True
​

访问列表中的列表中的值——类似于二维数组

>>> list5[1][0]       
'love'

6. 列表常用的其余函数——用dir（list）可以查看

（1）.count( )——计数某个元素出现的次数

>>> list1 = [123,456]
>>> list1 *=5
>>> list1
[123, 456, 123, 456, 123, 456, 123, 456, 123, 456]
>>> list1.count(123)
5

（2）.index( ， ， )——找某个元素出现的位置【2和3参数分别是范围的起始位置和结束位置】
　　　　　　　　　　　需要注意的是，索引和切片只能给有序数据（字符串、列表、元组）使用。 整型和布尔值等均不可以用来进行索引和切片操作。

>>> list1.index(456,2,5)
3

（3）.reverse( )——将整个列表反转，没有参数

>>> list1 = [123,456]
>>> list1 *=5
>>> list1
[123, 456, 123, 456, 123, 456, 123, 456, 123, 456]
​
>>> list1.reverse()
>>> list1
[456, 123, 456, 123, 456, 123, 456, 123, 456, 123]

（4）.sort(func , key , reverse=False\True)——默认为False，将列表元素从小到大排列
func指定算法，key是与算法搭配的关键字

>>> list6 = [5,2,7,11,9,456,8,35]
>>> list6.sort()
>>> list6
[2, 5, 7, 8, 9, 11, 35, 456]
#逆序排序
>>> list6.sort(reverse=True)
>>> list6
[456, 35, 11, 9, 8, 7, 5, 2]

要对一个列表进行逆序排序，请问使用什么方法？
假使列表名为list1，对其进行逆序排序
【1】list1.sort() 先正向排序，list1.reverse() 然后再逆向排序
【2】list1.sort(reverse=True) 一步到位

（5）关于分片拷贝的补充
分片拷贝是多了一个相同的列表，原列表改变后，新列表不变
列表拷贝就用分片
等号赋值是多了一个指向列表的标签，会随着原列表的改变而改变

>>> list7 = list6[:]
>>> list7
[456, 35, 11, 9, 8, 7, 5, 2]
>>> list8 = list6
>>> list6.sort()
>>> list6
[2, 5, 7, 8, 9, 11, 35, 456]
>>> list7
[456, 35, 11, 9, 8, 7, 5, 2]
>>> list8
[2, 5, 7, 8, 9, 11, 35, 456]

（6）.copy( )——复制列表

>>> member = ['一',1,'二',2,'三',3]
>>> list1 = member.copy()
>>> list1
['一', 1, '二', 2, '三', 3]

（7）.clear( )——清空列表

>>> list1.clear()
>>> list1
[]

7. 列表推导式——列表解析

列表推导式（List comprehensions）也叫列表解析，灵感取自函数式编程语言 Haskell。它是一个非常有用和灵活的工具，可以用来动态的创建列表，语法如：
[有关A的表达式 for A in B]

>>> list1 = [x ** 2 for x in range(5)]
>>> list1
[0, 1, 4, 9, 16]
#相当于
>>> list1 = []
>>> for x in range(5):
    list1.append(x ** 2)    
>>> list1
[0, 1, 4, 9, 16]

​

8. 总结：

（1）列表是可变数据类型，可迭代数据类型，有序的数据结构
（2）列表用来储存大量数据，并且可以储存不同数据类型
（3）列表都可以存放一些什么东西？————存放任何类型的数据，整型、浮点型、字符型，甚至还可以在列表中存放列表
（4）列表就是一个容器
（5）列表储存的是元素的内存地址
（6）member.append([ ‘x’ , ‘y’ ]) 和 member.extend([ ‘x’ , ‘y’ ]) 实现的效果一样吗？
member.append([ ‘x’ , ‘y’ ])是在列表的末尾追加了一个列表，列表[ ‘x’ , ‘y’ ]是作为一个元素存在；member.extend([ ‘x’ , ‘y’ ])是在列表的末尾追加了两个元素