一、列表

• 普通列表：列表元素类型一致

  >>> member=['刘昊然','秦霄贤','蛋黄派']
  >>> member
  ['刘昊然', '秦霄贤', '蛋黄派']
  >>> number=[1,2,3,4]
  >>> number
  [1, 2, 3, 4]

• 混合列表：列表元素类型不一致

  >>> mix=['刘昊然',1,2,3,'mine']
  >>> mix
  ['刘昊然', 1, 2, 3, 'mine']
  
  
  >>> mix=['刘昊然',1,2,3,'mine',[2,2,'heihei']]
  >>> mix
  ['刘昊然', 1, 2, 3, 'mine', [2, 2, 'heihei']]

• 空列表：预先给程序创建一个空列表，为后续程序使用

  >>>empty=[]

二、列表添加元素

• append（）
• 语法：对象.append(新增元素)
• 其中append是对象的方法，用 . 表示限制，只能逐个添加，但是参数可以是一个列表，即添加一个列表元素

  >>> mix
  ['刘昊然', 1, 2, 3, 'mine', [2, 2, 'heihei']]
  >>> mix.append('麦外敷')
  >>> mix
  ['刘昊然', 1, 2, 3, 'mine', [2, 2, 'heihei'], '麦外敷']
  
  
  >>> mix.append(6,8)
  Traceback (most recent call last):
    File "", line 1, in 
      mix.append(6,8)
  TypeError: append() takes exactly one argument (2 given)

• extend()
• 使用一个列表扩展另外一个列表，参数为列表，列表中的元素逐个插入列表

  >>> mix.extend(['love','you'])
  >>> mix
  ['刘昊然', 1, 2, 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love', 'you']

• append() 方法是将参数作为一个元素增加到列表的末尾。
  extend() 方法则是将参数作为一个列表去扩展列表的末尾。

  append(['a','b'])和extend(['a','b'])是不一样的

  >>> name = ['F', 'i', 's', 'h']
  >>> name.append('C')
  >>> name
  ['F', 'i', 's', 'h', 'C']
  >>> name.extend(['.', 'c'])
  >>> name
  ['F', 'i', 's', 'h', 'C', '.', 'c']
  >>> name.append(['o', 'm'])
  >>> name
  ['F', 'i', 's', 'h', 'C', '.', 'c', ['o', 'm']]

• insert()
• 语法：insert(想插入列表位置，元素)
• 可以设置插入位置，以上两个只能添加到末尾

  >>> mix.insert(0,'咩咩')
  >>> mix
  ['咩咩', '刘昊然', 1, 2, 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love', 'you']
  

三、列表元素的相关操作

• 获取列表元素
• 可以通过元素的索引值index从列表索取单个元素，注意索引值从0开始

• >>> member
  ['刘昊然', '秦霄贤', '蛋黄派']
  >>> member[0]
  '刘昊然'
  
  通过临时变量交换元素位置
  >>> temp=member[0]
  >>> member[0]=member[1]
  >>> member[1]=temp
  >>> member
  ['秦霄贤', '刘昊然', '蛋黄派']

• 删除列表元素
• remove
• 语法：对象.remove(参数)
• 只知道参数的名字即可删除，不用知道参数位置

• >>> mix
  ['咩咩', '刘昊然', 1, 2, 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love', 'you']
  >>> mix.remove('咩咩')
  >>> mix
  ['刘昊然', 1, 2, 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love', 'you']

• del
• 语法：del  列表[下标]可删除列表元素；del 列表可删除整个列表
• 不是函数也不是方法，而是一个语句

  >>> mix
  ['咩咩', '刘昊然', 1, 2, 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love', 'you']
  >>> mix.remove('咩咩')
  >>> mix
  ['刘昊然', 1, 2, 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love', 'you']
  >>> del mix[1]
  >>> mix
  ['刘昊然', 2, 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love', 'you']
  >>> del member
  >>> member
  Traceback (most recent call last):
    File "", line 1, in 
      member
  NameError: name 'member' is not defined

• pop()
• pop()：弹栈，member.pop(索引值)，默认弹出列表最后一个元素
• 语法：对象.pop()；对象.pop(索引)
• 默认从列表中弹出最后一个元素并返回，可指定位置，可用变量接收返回值

  >>> mix
  ['刘昊然', 2, 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love', 'you']
  >>> mix.pop()
  'you'
  >>> mix.pop(1)
  2
  >>> mix
  ['刘昊然', 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love']
  

四、列表切片

• 语法：对象[开始位置，结束位置]
• 利用列表切片可以一次性从列表获取多个元素,得到的是列表片段的拷贝，原列表不变
• 当不想对原列表进行修改但是想操作列表时可用 对象[ : ]获得列表拷贝
• 步长默认为1，不能为0，可以为负代表反向切片

• >>> mix
  ['刘昊然', 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love']
  >>> mix[1:3]
  [3, 'mine']
  >>> mix[:4]
  ['刘昊然', 3, 'mine', [2, 2, 'heihei']]
  >>> mix[2:]
  ['mine', [2, 2, 'heihei'], '麦外敷', 'love']
  >>> mix[:]
  ['刘昊然', 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love']
  >>> mix2=mix[:]
  >>> mix2
  ['刘昊然', 3, 'mine', [2, 2, 'heihei'], '麦外敷', 'love']

五、列表常用操作

• 比较操作符
• 列表进行比较时默认从第一个元素进行比较得到结果，根据第一个元素的比较结果作为列表比较结果，相等则继续比较下一个元素
• 字符串以ASCII码的形式进行比较

  >>> list1=[123]
  >>> list2=[234]
  >>> list1>> list3=[111,222]
  >>> list4=[222,111]
  >>> list3>list4
  False
  >>> list5=[111,222]
  >>> list6=[111,233]
  >>> list5>> list=['a','b']
  >>> l1=['a','b','c']
  >>> l2=['b','a']
  >>> l1>l2
  False
  
  字符串逐个比较
  >>> l3=['abc','ccc']
  >>> l4=['acb']
  >>> l3>> l4=['acb','aaa']
  >>> l3>l4
  False

•  连接操作符
• 可用+将两个列表连接在一起，但最好用extend连接，因为+不能实现新元素的添加操作，因为+两边类型应该一致，两边都是列表就可以

  >>> list1=['刘昊然','老公']
  >>> list2=['变成','富婆']
  >>> list1+=list2
  >>> list1
  ['刘昊然', '老公', '变成', '富婆']
  >>> list1+'富婆'
  Traceback (most recent call last):
    File "", line 1, in 
      list1+'富婆'
  TypeError: can only concatenate list (not "str") to list
  >>> list1.extend(list2)
  >>> list1
  ['刘昊然', '老公', '变成', '富婆', '变成', '富婆']

• 重复操作符

  >>> l4
  ['acb', 'aaa']
  >>> l4*2
  ['acb', 'aaa', 'acb', 'aaa']

• 成员关系操作符
• in/not in，返回值为bool型数据
• 只能判断一个层次的成员关系，例如列表中的列表中的元素不能单独判断，可以手动降低层次提取元素判断
• 访问列表中的列表中的元素可用二维切片的形式

  >>> l4
  ['acb', 'aaa', 'acb', 'aaa']
  >>> 'acb' in l4
  True
  >>> 'a' in l4
  False
  >>> 'a' in l4[0]
  True
  >>> l4[0][1]
  'c'
  >>> l4=['a',['b','c'],'d']
  >>> l4
  ['a', ['b', 'c'], 'd']
  >>> l4[1][0]
  'b'

• count()
• 语法：对象.count(元素)，返回整型数
• 作用是统计列表中某个元素出现的次数

  >>> list1
  ['刘昊然', '老公', '变成', '富婆', '变成', '富婆']
  >>> list1.count('富婆')
  2

• index()
• 语法：对象.index(元素),返回整型数；可指定搜索位置，对象.index(元素，起始位置，结束位置)
• 作用是返回元素在列表中指定范围的第一个索引值

  >>> list1
  ['刘昊然', '老公', '变成', '富婆', '变成', '富婆', '变成', '富婆', '富婆']
  >>> list1.index('富婆')
  3
  >>> list1.index('富婆',4)
  5
  >>> list1.index('富婆',4,7)
  5

• reverse()
• 语法：对象.reverse()，没有参数
• 逆转函数，将整个列表翻转

  >>> list3=[11,22,33,44,55]
  >>> list3.reverse()
  >>> list3
  [55, 44, 33, 22, 11]

• sort()
• sort(reverse=False)，含一个参数，默认为False，即升序，设置为True时为逆序
• 用指定的方法将整个列表排序，默认不需要参数，从小到大进行排序，默认是归并排序

  >>> list3=[11,22,33,44,55]
  >>> list3.reverse()
  >>> list3
  [55, 44, 33, 22, 11]
  >>> list3.sort(reverse=True)
  >>> list3
  [55, 44, 33, 22, 11]

六、关于分片拷贝问题

• 通过list2=list1[ : ]可以得到与list1相同的列表，对此拷贝列表操作不会影响原列表
• 通过list3=list1同样可以得到与list1相同的列表，但这不是拷贝得到，而是对原来的列表起了另外一个标签，对此列表操作会影响原列表

• >>> list1=[1,2,3,4,5,6]
  >>> list2=list1[:]
  >>> list2
  [1, 2, 3, 4, 5, 6]
  >>> list3=list1
  >>> list3
  [1, 2, 3, 4, 5, 6]
  >>> list2.sort(reverse=True)
  >>> list2
  [6, 5, 4, 3, 2, 1]
  >>> list1
  [1, 2, 3, 4, 5, 6]
  >>> list3.sort(reverse=True)
  >>> list3
  [6, 5, 4, 3, 2, 1]
  >>> list1
  [6, 5, 4, 3, 2, 1]

练习题：

1、请问 list1[0] 和 list1[0:1] 一样吗？

答：不一样，list1[0] 返回第0个元素的值，list1[0:1] 返回一个只含有第0个元素的列表

2、如果你每次想从列表的末尾取出一个元素，并将这个元素插入到列表的最前边，你会怎么做？

答： list1.insert(0, list1.pop())

3、Python支持负索引，所以使用负索引也可以访问列表数组

4、如何用列表切片完成列表翻转

• >>> a=[1,2,3,4]
  >>> a[::-1]
  [4, 3, 2, 1]

5、请问如何将下边这个列表的'小甲鱼'修改为'小鱿鱼'？

• >>>list1 = [1, [1, 2, ['小甲鱼']], 3, 5, 8, 13, 18]
  >>>list1[1][2][0] = '小鱿鱼'

  注意小鱿鱼所在也是一个列表，所以是三维切片

6、列表还有两个内置方法没给大家介绍，不过聪明的你应该可以自己摸索使用的门道吧：copy() 和 clear()

• >>> list1 = [1, [1, 2, ['小甲鱼']], 3, 5, 8, 13, 18]
  >>> list2 = list1.copy()
  >>> list1.clear()
  >>> list1
  []
  >>> list2
  [1, [1, 2, ['小甲鱼']], 3, 5, 8, 13, 18]
  >>> 

总结：

• 列表的常用操作符：
  比较：如果有多个元素，默认从第一个元素开始比较，比较对应的ASCII码值大小；
  逻辑（and or）：
  连接（+）：[1, 2, 3] + [4, 5, 6] 结果是 [1, 2, 3, 4, 5, 6]
  重复（*）：['Hi!'] * 4 结果是 ['Hi!', 'Hi!', 'Hi!', 'Hi!']
  成员关系（in 和 not in）：3 in [1, 2, 3] 结果是 True

• 列表的方法：dir(list)
  append()：在列表末尾添加新的对象
  extend()：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
  count()：统计出现的次数
  index(目标，起始位置，截止位置)：返回参数在列表中的位置
  insert()：将对象插入到列表指定位置
  pop()：移除列表中的一个元素（默认最后一个元素，可指定其他的位置），并且返回该元素的值
  remove()：移除列表中某个值的第一个匹配项（不能指定位置删除）
  reverse()：翻转列表
  sort()：按照指定的方式对列表成员排序，默认则从小到大排列
  特别的：sort(reverse=True)表示从大到小，默认为False

• 列表的内置函数：
  比较两个列表的元素：operator.eq(list1,list2）（前提需import operator）
  计算列表元素个数：len(list1)
  返回列表中元素最大值：max(list1)
  返回列表中元素最小值：min(list1)
  将元组转换为列表：list(tuple1)