list

  1. >>> classmates = ['Michael', 'Bob', 'Tracy']
  2. >>> len(classmates)                # 用len()函数可以获得list元素的个数
  3. >>> classmates[0]        # 用索引来访问list中每一个位置的元素，记得索引是从0开始的
  4.                         # 最后一个元素的索引是len(classmates) - 1
  5. >>> classmates[-1]        # 直接获取最后一个元素，类推，倒数第二个为 classmates[-2]

当索引超出范围时，Python会报一个IndexError错误。

切片

切片适用于提取序列的一部分，其中的编号非常重要：第一个索引是包含的第一个元素的编号，但第二个索引是切片后余下的第一个元素的编号，第三个参数是步长。

  1. numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
  2. numbers[3:6]             # [4, 5, 6] 
  3. numbers[-3:-1]            # [8, 9] 从列表末尾开始数，可使用负数索引
  4. numbers[-3:0]            # []
  5. numbers[-3:]            # [8, 9, 10] 如果切片结束于序列末尾，可省略第二个索引
  6. numbers[:3]             # [1, 2, 3] 切片始于序列开头，可省略第一个索引
  7. numbers[:]                # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 复制整个序列，可将两个索引都省略
  9. # 步长不能为0
  10. numbers[0:10:2]         # [1, 3, 5, 7, 9] 
  11. numbers[::4]            # [1, 5, 9]    
  13. # 插入新元素
  14. >>> numbers = [1, 5] 
  15. >>> numbers[1:1] = [2, 3, 4] 
  16. >>> numbers 
  17. [1, 2, 3, 4, 5]

添加和删除

  1. >>> classmates.append('Adam')            # 往list中追加元素到末尾
  2. >>> classmates.insert(1, 'Jack')        # 把元素插入到指定位置，如索引号为1的位置
  3. >>> classmates.pop()                    # 删除list末尾的元素
  4. >>> classmates.pop(1)                    # 删除指定位置的元素，用pop(i)，i是索引位置
  5. >>> classmates[1] = 'Sarah'                # 直接赋值给对应的索引位置，替换元素
  6. >>> classmates.clear()                     # 就地清空列表
  9. # 使用 del 语句删除元素，列表长度会减少
  10. >>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl'] 
  11. >>> del names[2]
  12. >>> names 
  13. ['Alice', 'Beth', 'Dee-Dee', 'Earl']
  14. >>> names[1:4] = []            # 切片替换删除，与del names[1:4]等效
  15. >>> names
  16. ['Alice']

复制

  1. # number1,2,3指向不同的列表
  2. number1 = [1,2,3,4,5]
  3. number2 = number[:]            # 切片复制
  4. number3 = list(number1)        # list复制

append

将一个对象附加到列表末尾。(直接修改旧列表。)

  1. >>> lst = [1,2,3]
  2. >>> lst.append(4)
  3. >>> lst
  4. [1,2,3,4]

clear

就地清空列表的内容

  1. >>> lst = [1,2,3]
  2. >>> lst.clear()
  3. >>> lst
  4. []            #

类似于切片赋值语句 lst[:] = []。
del lst[:]也可达到同样效果。

copy

复制列表。与常规复制lst1 = lst2只是将另一个名称关联到列表不同。

  1. >>> a = [1,2,3]
  2. >>> b = a.copy()
  3. >>> b[1] = 4
  4. >>> a
  5. [1,2,3]

类似于使用a[:]或list(a),都是复制a。

count

计算指定的元素在列表中出现了多少次。

  1. >>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')
  2. 2
  3. >>> x = [[1,2], 1, 1, [2, 1 ,[1, 2]]]
  4. >>> x.count(1)
  5. 2
  6. >>> x.count([1, 2])

extend

同时将多个值附加到列表末尾。

  1. >>> a = [1, 2, 3] 
  2. >>> b = [4, 5, 6] 
  3. >>> a.extend(b) 
  4. >>> a 
  5. [1, 2, 3, 4, 5, 6]

类似于拼接，但存在一个重要差别。常规拼接中，情况是返回一个全新的序列。而
extend修改被扩展的序列。

  1. >>> a = [1, 2, 3] 
  2. >>> b = [4, 5, 6] 
  3. >>> a + b 
  4. [1, 2, 3, 4, 5, 6] 
  5. >>> a 
  6. [1, 2, 3]

index

在列表中查找指定值第一次出现的索引。
搜索不存在的元素，会报错。

  1. >>> knights = ['we', 'are', 'the', 'knignts', 'who', 'say', 'ni']
  2. >>> knights.index('who')
  3. 4

insert

将一个对象插入列表。

  1. >>> numbers = [1,2,3,5,6,7]
  2. >>> numbers.insert(3, 'four')
  3. >>> numbers
  4. [1,2,3,'four',5,6,7]

也可用切片赋值来获得一样的效果，但可读性不如insert.

  1. >>> numbers = [1,2,3,5,6,7]
  2. >>> numbers[3:3] = ['four']
  3. >>> numbers
  4. [1,2,3,'four',5,6,7]

pop

从列表中删除一个元素（默认为末尾为最后一个元素），并返回这一元素。（即返回删除的元素）。

  1. >>> x = [1,2,3]
  2. >>> x.pop()
  3. 3
  4. >>> x
  5. [1,2]
  6. >>> x.pop(0)
  7. 1
  8. >>> x
  9. [2]

注意 pop是唯一既修改列表又返回一个非None值的列表方法。

Python没有提供push，但可用append替代。要创建先进先出的队列，可使用insert(0, ...)代替append。

remove

用于删除第一个为指定值的元素。删除不存在的值会报错。

  1. >>> x = ['to', 'be', 'or', 'not', 'to', 'be']
  2. >>> x.remove('be')
  3. >>> x
  4. ['to', 'or', 'not', 'to', 'be']

remove是就地修改且不返回值的方法之一。

reverse

按相反的顺序排列列表中的元素。

  1. >>> x = [1,2,3]
  2. >>> x.reserve()
  3. >>> x
  4. [3,2,1]

remove修改列表，但不返回任何值。

sort

对列表就地排序。

  1. >>> x = [4,6,2,1,7,9]
  2. >>> x.sort()
  3. >>> x
  4. [1,2,4,6,7,9]

为获取排序后的列表的副本，另一种方式是使用函数sorted。

  1. >>> x = [4,6,2,1,7,9]
  2. >>> y = sorted(x)
  3. >>> x
  4. [4,6,2,1,7,9]
  5. >>> y

函数sorted可用于任何可迭代的对象，但总是返回一个列表。

高级排序

方法sort接受两个可选(关键字)参数：key和reverse。

  1. # key其设置为一个用于排序的函数
  2. >>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate'] 
  3. >>> x.sort(key=len) 
  4. >>> x 
  5. ['add', 'acme', 'aerate', 'abalone', 'aardvark']
  7. # reverse指定为一个真值,指出是否要按相反的顺序对列表进行排序
  8. >>> x = [4, 6, 2, 1, 7, 9] 
  9. >>> x.sort(reverse=True) 
  10. >>> x 
  11. [9, 7, 6, 4, 2, 1]

tuple

和list非常类似，但是tuple一旦初始化就不能修改。
获取元素的方法和list是一样，但不能赋值成另外的元素。

  1. >>> x = 1, 2, 3 
  2. >>> x
  3. (1, 2, 3)
  5. >>> t = ()                # 定义一个空的tuple
  6. >>> t = (1,)            # 定义一个只有1个元素的tuple，不能写成t = (1)
  7. >>> t
  8. (1,)                    # Python在显示只有一个元素的tuple时也会加逗号避免歧义。
  9. >>> t = (1, 2)
  11. >>> 3 * (40 + 2) 
  12. 126 
  13. >>> 3 * (40 + 2,) 
  14. (42, 42, 42)
  1. # 可变的tuple
  2. >>> t = ('a', 'b', ['A', 'B'])
  3. >>> t[2][1] = 'X'