Python 复习笔记(三)

1. 列表操作——改变元素值：
   x = [1, 2, 3]
   x[1] = 0

2. 列表操作——删除元素(del)：
   names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
   del name[2]

3. 列表操作——切片赋值：
   name = list['Perl']
   name[1:] = list['ython']
   name    # ['P', 'y', 't', 'h', 'o', 'n']

   numbers = [1, 5]
   numbers[1:1] = [2, 3, 4]  # 不需要替换任何原有元素的情况下插入新的元素
   numbers    # [1, 2, 3, 4, 5]

   numbers = [1, 2, 4, 5]
   numbers[1:4] = []  # 从第２个元素到第４个元素都是空值
   numbers    # [1, 5]

4. 列表的方法
　　1) append, 在列表尾部添加新的元素
    lst = [1, 2, 3]
    lst.append(4)

    2) cout, 统计某个元素在列表中出现的次数，并返回值
    x = [[1,2], 1, 1,[2,1,[1, 2]]]
    x.count(1)  # 结果是2,　因为它统计x列表中单个元素的次数

    3) extend, 在列表尾部追加一个列表的值
　　a = [1, 2, 3]
    b = [4, 5, 6]
    a.extend(b)  
    a   # [1, 2, 3, 4, 5, 6]
   此方法看上去像连接，两者主要的区别是extend将列表扩展了，并返回一个新的列表，　而连接不会扩展原来的列表。　

　　4) index, 查找元素在列表中的第一次出现的索引位置，如果找不到引发一个异常
    a = [5, 3, 7, 3, 9]
    a.index(3)  # 1

    5) insert, 在列表指定位置插入元素，且一次只能插入一个元素
    numbers = [1, 2, 3, 5, 6, 7]
    numbers.insert(3, 'four')

    6) pop, 移除列表最后一个元素，并返回被移除的元素值
　　 x = [1, 2, 3]
     x.pop()  # 3
     pop 在操作一个空的列表时，将引发一个异常
     pop(出栈) 与 append(入栈) 可实现一种数据结构"栈"
    
    7) remove, 移除列表中第一个满足条件值的元素
     x = ['to', 'be', 'or', 'not', 'to', 'be']
     x.remove('be') # 移除x列表中的第２个元素

    8) reverse, 将列表元素反向存储(倒序存储)，但不返回值
    x = [1, 2, 3]
    x.reverse()

    9) sort, 对列表按照升序进行排序，返回一个空值
　　x = [3, 6, 2, 1, 7, 9]
    x.sort()
    x  # [1, 2, 3, 6, 7, 9]
    排序后，原来的列表已被修改，如果要保留原来的副本，可以：
    x = [3, 6, 2, 1, 7, 9]
    y  = x[:] # 将原列表赋值给另外一个列表，这里不能 y = x，因为这样操作后，x, y都会指向同一个地址
　　y.sort()  # 对被赋值的列表排序
    x         #　原列表不变
    当然还有个函数(它不是列表的方法)较为直接，它返回排序后的值，且不修改原列表
    x = [3, 6, 2, 1, 7, 9]
    y = sorted(x) # 原列表不变，返回排序后的结果

　　当然，如果你的按降序排序，需要配合上面的 reverse 方法。

    10) 高级排序
　　以cmp 函数为参数排序，如：
　　numbers = [3, 6, 2, 1, 7, 9]
    numbers.sort(cmp)  # 以升序排序，这个看来和sort()方法一样；
    sort方法还有另外两个可选参数：key和reverse, 使用key参数排序必须提供一个在排序过程中使用的函数，如：
    x = ['aardeark', 'abalone', 'acme', 'add', 'aerate']
    x.sort(key = len)  # 以字符长度为排序依据
　　reverse是简单的布尔值排序，reverse = True时，按降序排序，reverse = False时，按升序排序：
    x = [3, 6, 2, 1, 7, 9]
    x.sort(reverse = True)

5.　元组
   元组与列表一样，唯一不同是元组不能修改，它是用圆括号括起来的.
   空元组是：()
   只有一个元组：(3, )  # 如果没有一个逗号，会认为是一个常量
   ()内可以做运算，如：
   (5-2, 6)  # (3, 6)
   (5 > 3, 6) # (True, 6)
   如果在()用*号，则：
   3 * (2, )  # (2, 2, 2)
   (2, ) * 3  # (2, 2, 2),(2, )如果没有逗号，则是 2 * 3 = 6

6. 将列表转换为元组: tuple()
   a = [12, 3, 8]
   tuple(a)
   如果a是一个元组，则还是返回元组。